proxygen: fizz::server::test Namespace Reference

using fizz::server::test::MockAsyncFizzServer = typedef MockAsyncFizzServerT<ServerStateMachine>

Definition at line 175 of file Mocks.h.

using fizz::server::test::MockHandshakeCallback = typedef MockHandshakeCallbackT<ServerStateMachine>

Definition at line 159 of file Mocks.h.

using fizz::server::test::TestAeadTicketCipher = typedef AeadTicketCipher< OpenSSLEVPCipher<AESGCM128>, MockTicketCodec, HkdfImpl<Sha256>>

Definition at line 77 of file AeadTicketCipherTest.cpp.

template<typename... Args>

AsyncActions fizz::server::test::actions ( Args &&... act )

Definition at line 28 of file AsyncFizzServerTest.cpp.

References fizz::server::detail::actions().

Referenced by fizz::server::test::AsyncFizzServerTest::accept(), fizz::server::test::AsyncFizzServerTest::fullHandshakeSuccess(), and TEST_F().

                                     {
   return fizz::server::detail::actions(std::forward<Args>(act)...);
 }

static std::string fizz::server::test::generateRandomString	(	size_t	minimum,
		size_t	maximum
	)

static

Definition at line 24 of file SlidingBloomReplayCacheTest.cpp.

References folly::Random::rand64(), and string.

Referenced by TEST().

                                                                       {
   size_t length = Random::rand64(minimum, maximum + 1);
   auto randchar = []() -> char {
     const char kCharset[] =
         "0123456789+/=-_"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "abcdefghijklmnopqrstuvwxyz";
     return kCharset[Random::rand64(0, sizeof(kCharset))];
   };
   std::string str(length, 0);
   std::generate_n(str.begin(), length, randchar);
   return str;
 }

static ResumptionState fizz::server::test::getTestResumptionState	(	std::shared_ptr< SelfCert >	cert,
		std::shared_ptr< PeerCert >	peerCert
	)

static

Definition at line 38 of file TicketCodecTest.cpp.

References fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::cipher, fizz::server::ResumptionState::clientCert, folly::IOBuf::copyBuffer(), fizz::server::ResumptionState::resumptionSecret, fizz::server::ResumptionState::serverCert, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::ResumptionState::version.

Referenced by TEST().

                                       {
   ResumptionState rs;
   rs.version = ProtocolVersion::tls_1_3;
   rs.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
   rs.resumptionSecret = IOBuf::copyBuffer("secret");
   rs.serverCert = cert;
   rs.clientCert = peerCert;
   rs.ticketAgeAdd = 0x44444444;
   rs.ticketIssueTime = std::chrono::time_point<std::chrono::system_clock>(
       std::chrono::seconds(25));
   rs.alpn = "h2";
   return rs;
 }

static std::unique_ptr<IOBuf> fizz::server::test::getV2ClientHello ( )

static

Definition at line 77 of file FizzServerTest.cpp.

References folly::IOBuf::copyBuffer(), and folly::unhexlify().

Referenced by TEST_F().

                                                {
   // This client hello is truncated but is sufficient to trigger the fallback.
   static constexpr StringPiece v2ClientHello =
       "808c0103010063000000200000390000380000350000";
   return IOBuf::copyBuffer(folly::unhexlify(v2ClientHello));
 }

fizz::server::test::MATCHER_P	(	BufMatches	,
		expected	,
		""
	)

Definition at line 129 of file AsyncFizzServerTest.cpp.

References folly::eq.

                                     {
   folly::IOBufEqualTo eq;
   return eq(*arg, *expected);
 }

fizz::server::test::TEST	(	DualCipherTest	,
		Encryption
	)

Definition at line 19 of file DualTicketCipherTest.cpp.

References testing::_, cipher, EXPECT_CALL, and folly::gen::move.

                                  {
   auto cipher = std::make_unique<MockTicketCipher>();
   auto fallbackCipher = std::make_unique<MockTicketCipher>();
   ResumptionState resState;
 
   cipher->setDefaults();
   fallbackCipher->setDefaults();
   EXPECT_CALL(*cipher, _encrypt(_)).Times(1);
   EXPECT_CALL(*fallbackCipher, _encrypt(_)).Times(0);
 
   auto dualCipher =
       DualTicketCipher(std::move(cipher), std::move(fallbackCipher));
   dualCipher.encrypt(std::move(resState));
 }

fizz::server::test::TEST	(	NegotiatorTest	,
		TestSingle
	)

Definition at line 20 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                  {
   std::vector<std::vector<int>> server = {{1}};
   std::vector<int> client = {1};
 
   EXPECT_EQ(*negotiate(server, client), 1);
 }

fizz::server::test::TEST	(	NegotiatorTest	,
		TestSingleMismatch
	)

Definition at line 27 of file NegotiatorTest.cpp.

References EXPECT_FALSE, and fizz::server::negotiate().

                                          {
   std::vector<std::vector<int>> server = {{1}};
   std::vector<int> client = {2};
 
   EXPECT_FALSE(negotiate(server, client).hasValue());
 }

fizz::server::test::TEST	(	GetStatelessHrrTest	,
		NoGroup
	)

Definition at line 31 of file CookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::server::getStatelessHelloRetryRequest(), folly::hexlify(), folly::none, statelessHrr, fizz::tls_1_3, and fizz::TLS_AES_128_GCM_SHA256.

                                    {
   auto hrr = getStatelessHelloRetryRequest(
       ProtocolVersion::tls_1_3,
       CipherSuite::TLS_AES_128_GCM_SHA256,
       none,
       IOBuf::copyBuffer("test"));
   EXPECT_EQ(hexlify(hrr->coalesce()), statelessHrr);
 }

fizz::server::test::TEST	(	DualCipherTest	,
		DecryptSuccess
	)

Definition at line 34 of file DualTicketCipherTest.cpp.

References testing::_, cipher, EXPECT_CALL, testing::InvokeWithoutArgs(), folly::gen::move, fizz::Resumption, and folly::IOBuf::wrapBuffer().

                                      {
   auto cipher = std::make_unique<MockTicketCipher>();
   auto fallbackCipher = std::make_unique<MockTicketCipher>();
   ResumptionState resState;
 
   EXPECT_CALL(*cipher, _decrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     ResumptionState res;
     return std::make_pair(PskType::Resumption, std::move(res));
   }));
   EXPECT_CALL(*fallbackCipher, _decrypt(_)).Times(0);
 
   auto dualCipher =
       DualTicketCipher(std::move(cipher), std::move(fallbackCipher));
   auto buf =
       folly::IOBuf::wrapBuffer(folly::ByteRange(folly::StringPiece("ss")));
   dualCipher.decrypt(std::move(buf));
 }

fizz::server::test::TEST	(	NegotiatorTest	,
		TestServerPref
	)

Definition at line 34 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                      {
   std::vector<std::vector<int>> server = {{1}, {2}, {3}};
   std::vector<int> client = {3, 1, 2};
 
   EXPECT_EQ(*negotiate(server, client), 1);
 }

fizz::server::test::TEST	(	GetStatelessHrrTest	,
		Group
	)

Definition at line 40 of file CookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::server::getStatelessHelloRetryRequest(), folly::hexlify(), statelessHrrGroup, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                  {
   auto hrr = getStatelessHelloRetryRequest(
       ProtocolVersion::tls_1_3,
       CipherSuite::TLS_AES_128_GCM_SHA256,
       NamedGroup::x25519,
       IOBuf::copyBuffer("test"));
   EXPECT_EQ(hexlify(hrr->coalesce()), statelessHrrGroup);
 }

fizz::server::test::TEST	(	NegotiatorTest	,
		TestServerPrefTie
	)

Definition at line 41 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                         {
   std::vector<std::vector<int>> server = {{1}, {2, 4}, {3}};
   std::vector<int> client = {5, 6, 4, 2};
 
   EXPECT_EQ(*negotiate(server, client), 4);
 }

fizz::server::test::TEST	(	SlidingBloomReplayCacheTest	,
		TestSimpleGetSet
	)

Definition at line 42 of file SlidingBloomReplayCacheTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, generateRandomString(), i, fizz::server::SlidingBloomReplayCache::set(), fizz::server::SlidingBloomReplayCache::test(), and toRange().

                                                     {
   const int numTries = 1 << 14;
   SlidingBloomReplayCache cache(12, numTries, 0.0005, nullptr);
   std::vector<std::string> history(numTries);
   for (size_t i = 0; i < numTries; i++) {
     history[i] = generateRandomString(8, 64);
     EXPECT_FALSE(cache.test(toRange(history[i])));
   }
   for (size_t i = 0; i < numTries; i++) {
     cache.set(toRange(history[i]));
     EXPECT_TRUE(cache.test(toRange(history[i])));
   }
 }

fizz::server::test::TEST	(	NegotiateTest	,
		TestSingleOrdering
	)

Definition at line 48 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                         {
   std::vector<int> server = {1, 2, 3};
   std::vector<int> client = {3, 1, 2};
 
   EXPECT_EQ(*negotiate(server, client), 1);
 }

fizz::server::test::TEST	(	DualCipherTest	,
		DecryptSuccessWithFallback
	)

Definition at line 52 of file DualTicketCipherTest.cpp.

References testing::_, cipher, EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, fizz::Rejected, fizz::Resumption, and folly::IOBuf::wrapBuffer().

                                                  {
   auto cipher = std::make_unique<MockTicketCipher>();
   auto fallbackCipher = std::make_unique<MockTicketCipher>();
   ResumptionState resState;
 
   EXPECT_CALL(*cipher, _decrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     ResumptionState res;
     return std::make_pair(PskType::Rejected, std::move(res));
   }));
   EXPECT_CALL(*fallbackCipher, _decrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     ResumptionState res;
     return std::make_pair(PskType::Resumption, std::move(res));
   }));
 
   auto dualCipher =
       DualTicketCipher(std::move(cipher), std::move(fallbackCipher));
   auto buf =
       folly::IOBuf::wrapBuffer(folly::ByteRange(folly::StringPiece("ss")));
   EXPECT_EQ(
       std::get<0>(dualCipher.decrypt(std::move(buf)).get()),
       PskType::Resumption);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncode
	)

Definition at line 54 of file TicketCodecTest.cpp.

References encode(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, getTestResumptionState(), folly::hexlify(), folly::gen::move, testing::Return(), ticket, and fizz::test::toIOBuf().

                                   {
   auto cert = std::make_shared<MockSelfCert>();
   auto rs = getTestResumptionState(cert, nullptr);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_FALSE(rs.appToken);
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   EXPECT_TRUE(IOBufEqualTo()(encoded, toIOBuf(ticket)))
       << folly::hexlify(encoded->coalesce());
 }

fizz::server::test::TEST	(	NegotiateTest	,
		TestSingleOrderingLast
	)

Definition at line 55 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                             {
   std::vector<int> server = {4, 5, 3};
   std::vector<int> client = {3, 1, 2};
 
   EXPECT_EQ(*negotiate(server, client), 3);
 }

fizz::server::test::TEST	(	SlidingBloomReplayCacheTest	,
		TestSimpleTestAndSet
	)

Definition at line 56 of file SlidingBloomReplayCacheTest.cpp.

References EXPECT_LT, EXPECT_TRUE, generateRandomString(), i, fizz::server::SlidingBloomReplayCache::test(), fizz::server::SlidingBloomReplayCache::testAndSet(), and toRange().

                                                         {
   const int numTries = 1 << 14;
   SlidingBloomReplayCache cache(12, numTries, 0.0005, nullptr);
   std::vector<std::string> history(numTries);
   size_t falsePositives = 0;
   for (size_t i = 0; i < numTries; i++) {
     history[i] = generateRandomString(8, 64);
     if (cache.testAndSet(toRange(history[i]))) {
       falsePositives++;
     }
   }
 
   for (size_t i = 0; i < numTries; i++) {
     EXPECT_TRUE(cache.test(toRange(history[i])));
   }
 
   double actualErrorRate = static_cast<double>(falsePositives) / numTries;
   EXPECT_LT(actualErrorRate, 0.0005);
 }

fizz::server::test::TEST	(	NegotiateTest	,
		TestSingleOrderingNoMatch
	)

Definition at line 62 of file NegotiatorTest.cpp.

References EXPECT_FALSE, and fizz::server::negotiate().

                                                {
   std::vector<int> server = {1, 5, 6};
   std::vector<int> client = {3, 4, 2};
 
   EXPECT_FALSE(negotiate(server, client).hasValue());
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncodeWithAppToken
	)

Definition at line 64 of file TicketCodecTest.cpp.

References folly::IOBuf::copyBuffer(), encode(), EXPECT_CALL, EXPECT_TRUE, getTestResumptionState(), folly::hexlify(), folly::gen::move, testing::Return(), ticketWithAppToken, and fizz::test::toIOBuf().

                                               {
   auto cert = std::make_shared<MockSelfCert>();
   auto rs = getTestResumptionState(cert, nullptr);
   rs.appToken = IOBuf::copyBuffer("hello world");
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   EXPECT_TRUE(IOBufEqualTo()(encoded, toIOBuf(ticketWithAppToken)))
       << folly::hexlify(encoded->coalesce());
 }

fizz::server::test::TEST	(	NegotiateTest	,
		TestServerEmptyTier
	)

Definition at line 69 of file NegotiatorTest.cpp.

References EXPECT_EQ, and fizz::server::negotiate().

                                          {
   std::vector<std::vector<int>> server = {{}, {4}};
   std::vector<int> client = {3, 4, 2};
 
   EXPECT_EQ(*negotiate(server, client), 4);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncodeNoAlpn
	)

Definition at line 74 of file TicketCodecTest.cpp.

References encode(), EXPECT_CALL, EXPECT_TRUE, getTestResumptionState(), folly::hexlify(), folly::gen::move, folly::none, testing::Return(), ticketNoAlpn, and fizz::test::toIOBuf().

                                         {
   auto cert = std::make_shared<MockSelfCert>();
   auto rs = getTestResumptionState(cert, nullptr);
   rs.alpn = none;
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   EXPECT_TRUE(IOBufEqualTo()(encoded, toIOBuf(ticketNoAlpn)))
       << folly::hexlify(encoded->coalesce());
 }

fizz::server::test::TEST	(	SlidingBloomReplayCacheTest	,
		TestCacheErrorRate
	)

Definition at line 76 of file SlidingBloomReplayCacheTest.cpp.

References EXPECT_LT, generateRandomString(), i, needle, seen, fizz::server::SlidingBloomReplayCache::set(), string, fizz::server::SlidingBloomReplayCache::test(), and toRange().

                                                       {
   const int numTries = 1 << 14;
   SlidingBloomReplayCache cache(12, numTries, 0.0005, nullptr);
   std::vector<std::string> history(numTries);
   for (size_t i = 0; i < numTries; i++) {
     history[i] = generateRandomString(8, 64);
     cache.set(toRange(history[i]));
   }
 
   size_t falsePositives = 0;
   std::unordered_set<std::string> seen(history.begin(), history.end());
 
   for (size_t i = 0; i < numTries; i++) {
     std::string needle;
     do {
       needle = generateRandomString(8, 64);
     } while (seen.count(needle) == 1);
     seen.insert(needle);
     if (cache.test(toRange(needle))) {
       falsePositives++;
     }
   }
 
   double actualErrorRate = static_cast<double>(falsePositives) / numTries;
   EXPECT_LT(actualErrorRate, 0.001);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncodeClientAuthX509
	)

Definition at line 84 of file TicketCodecTest.cpp.

References encode(), EXPECT_CALL, EXPECT_TRUE, fizz::test::getCert(), getTestResumptionState(), folly::hexlify(), testing::Invoke(), fizz::test::kRSACertificate, folly::gen::move, testing::Return(), ticketClientAuthX509, and fizz::test::toIOBuf().

                                                 {
   auto cert = std::make_shared<MockSelfCert>();
   auto peerCert = std::make_shared<MockPeerCert>();
   auto rs = getTestResumptionState(cert, peerCert);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_CALL(*peerCert, getX509()).Times(2).WillRepeatedly(Invoke([]() {
     return getCert(kRSACertificate);
   }));
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   EXPECT_TRUE(IOBufEqualTo()(encoded, toIOBuf(ticketClientAuthX509)))
       << folly::hexlify(encoded->coalesce());
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncodeClientAuthIdentityOnly
	)

Definition at line 97 of file TicketCodecTest.cpp.

References encode(), EXPECT_CALL, EXPECT_TRUE, getTestResumptionState(), folly::hexlify(), folly::gen::move, testing::Return(), ticketClientAuthIdentityOnly, and fizz::test::toIOBuf().

                                                         {
   auto cert = std::make_shared<MockSelfCert>();
   auto peerCert = std::make_shared<MockPeerCert>();
   auto rs = getTestResumptionState(cert, peerCert);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_CALL(*peerCert, getIdentity()).WillOnce(Return("clientid"));
   auto encoded =
       TicketCodec<CertificateStorage::IdentityOnly>::encode(std::move(rs));
   EXPECT_TRUE(IOBufEqualTo()(encoded, toIOBuf(ticketClientAuthIdentityOnly)))
       << folly::hexlify(encoded->coalesce());
 }

fizz::server::test::TEST	(	SlidingBloomReplayCacheTest	,
		TestTimeBucketing
	)

Definition at line 103 of file SlidingBloomReplayCacheTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, generateRandomString(), i, folly::EventBase::loop(), folly::ScheduledExecutor::now(), folly::EventBase::scheduleAt(), fizz::server::SlidingBloomReplayCache::set(), folly::EventBase::terminateLoopSoon(), fizz::server::SlidingBloomReplayCache::test(), and toRange().

                                                      {
   const int numTries = 1 << 14;
 
   folly::EventBase evb;
   SlidingBloomReplayCache cache(12, numTries, 0.0005, &evb);
 
   std::vector<std::string> history(numTries);
   for (size_t i = 0; i < numTries; i++) {
     history[i] = generateRandomString(8, 64);
     cache.set(toRange(history[i]));
   }
 
   // 6 seconds in, all values should still be set
   evb.scheduleAt(
       [&] {
         for (int i = 0; i < numTries; ++i) {
           EXPECT_TRUE(cache.test(toRange(history[i])));
         }
       },
       evb.now() + std::chrono::seconds(6));
 
   // 13 seconds in, all should be gone.
   evb.scheduleAt(
       [&] {
         for (int i = 0; i < numTries; ++i) {
           EXPECT_FALSE(cache.test(toRange(history[i])));
         }
         evb.terminateLoopSoon();
       },
       evb.now() + std::chrono::seconds(13));
   evb.loop();
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestEncodeNoX509
	)

Definition at line 109 of file TicketCodecTest.cpp.

References fizz::decode(), encode(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, getTestResumptionState(), testing::Invoke(), folly::gen::move, and testing::Return().

                                         {
   auto cert = std::make_shared<MockSelfCert>();
   auto peerCert = std::make_shared<MockPeerCert>();
   auto rs = getTestResumptionState(cert, peerCert);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_CALL(*peerCert, getX509()).WillOnce(Invoke([]() { return nullptr; }));
   EXPECT_CALL(*peerCert, getIdentity()).WillOnce(Return("clientid"));
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   auto drs = TicketCodec<CertificateStorage::X509>::decode(
       std::move(encoded), nullptr);
   EXPECT_TRUE(drs.clientCert);
   EXPECT_EQ(drs.clientCert->getIdentity(), "clientid");
   EXPECT_EQ(drs.clientCert->getX509(), nullptr);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeDifferentStorage
	)

Definition at line 124 of file TicketCodecTest.cpp.

References fizz::decode(), encode(), EXPECT_CALL, EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, fizz::test::getCert(), getTestResumptionState(), testing::Invoke(), fizz::test::kRSACertificate, folly::gen::move, and testing::Return().

                                                   {
   auto cert = std::make_shared<MockSelfCert>();
   auto peerCert = std::make_shared<MockPeerCert>();
   auto rs = getTestResumptionState(cert, peerCert);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_CALL(*peerCert, getX509()).Times(2).WillRepeatedly(Invoke([]() {
     return getCert(kRSACertificate);
   }));
   auto encoded = TicketCodec<CertificateStorage::X509>::encode(std::move(rs));
   auto drs = TicketCodec<CertificateStorage::IdentityOnly>::decode(
       std::move(encoded), nullptr);
   EXPECT_TRUE(drs.clientCert);
   EXPECT_EQ(drs.clientCert->getIdentity(), "Fizz");
   EXPECT_NE(drs.clientCert->getX509(), nullptr);
 
   rs = getTestResumptionState(cert, peerCert);
   EXPECT_CALL(*cert, getIdentity()).WillOnce(Return("ident"));
   EXPECT_CALL(*peerCert, getIdentity()).WillOnce(Return("FizzIdOnly"));
   auto encodedIdOnly =
       TicketCodec<CertificateStorage::IdentityOnly>::encode(std::move(rs));
   auto drsX509 = TicketCodec<CertificateStorage::X509>::decode(
       std::move(encodedIdOnly), nullptr);
   EXPECT_TRUE(drsX509.clientCert);
   EXPECT_EQ(drsX509.clientCert->getIdentity(), "FizzIdOnly");
   EXPECT_EQ(drsX509.clientCert->getX509(), nullptr);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecode
	)

Definition at line 151 of file TicketCodecTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::decode(), EXPECT_EQ, EXPECT_TRUE, ticketClientAuthX509, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::test::toIOBuf().

                                   {
   auto rs = TicketCodec<CertificateStorage::X509>::decode(
       toIOBuf(ticketClientAuthX509), nullptr);
   EXPECT_EQ(rs.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(rs.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_TRUE(IOBufEqualTo()(rs.resumptionSecret, IOBuf::copyBuffer("secret")));
   EXPECT_EQ(rs.ticketAgeAdd, 0x44444444);
   EXPECT_EQ(
       rs.ticketIssueTime,
       std::chrono::time_point<std::chrono::system_clock>(
           std::chrono::seconds(25)));
   EXPECT_EQ(*rs.alpn, "h2");
   EXPECT_TRUE(rs.clientCert);
   EXPECT_EQ(rs.clientCert->getIdentity(), "Fizz");
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeNoAlpn
	)

Definition at line 167 of file TicketCodecTest.cpp.

References fizz::decode(), EXPECT_FALSE, ticketNoAlpn, and fizz::test::toIOBuf().

                                         {
   auto rs = TicketCodec<CertificateStorage::X509>::decode(
       toIOBuf(ticketNoAlpn), nullptr);
   EXPECT_FALSE(rs.alpn.hasValue());
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeTooShort
	)

Definition at line 173 of file TicketCodecTest.cpp.

References EXPECT_THROW, folly::gen::move, ticket, and fizz::test::toIOBuf().

                                           {
   auto buf = toIOBuf(ticket);
   buf->trimEnd(1);
   EXPECT_THROW(
       TicketCodec<CertificateStorage::X509>::decode(std::move(buf), nullptr),
       std::exception);
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeWithAppToken
	)

Definition at line 181 of file TicketCodecTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::decode(), EXPECT_EQ, EXPECT_TRUE, ticketWithAppToken, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::test::toIOBuf().

                                               {
   auto rs = TicketCodec<CertificateStorage::X509>::decode(
       toIOBuf(ticketWithAppToken), nullptr);
   EXPECT_EQ(rs.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(rs.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_TRUE(IOBufEqualTo()(rs.resumptionSecret, IOBuf::copyBuffer("secret")));
   EXPECT_EQ(rs.ticketAgeAdd, 0x44444444);
   EXPECT_EQ(
       rs.ticketIssueTime,
       std::chrono::time_point<std::chrono::system_clock>(
           std::chrono::seconds(25)));
   EXPECT_EQ(*rs.alpn, "h2");
   EXPECT_TRUE(IOBufEqualTo()(rs.appToken, IOBuf::copyBuffer("hello world")));
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeWithEmptyAppToken
	)

Definition at line 196 of file TicketCodecTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::decode(), EXPECT_EQ, EXPECT_TRUE, ticket, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::test::toIOBuf().

                                                    {
   auto rs =
       TicketCodec<CertificateStorage::X509>::decode(toIOBuf(ticket), nullptr);
   EXPECT_EQ(rs.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(rs.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_TRUE(IOBufEqualTo()(rs.resumptionSecret, IOBuf::copyBuffer("secret")));
   EXPECT_EQ(rs.ticketAgeAdd, 0x44444444);
   EXPECT_EQ(
       rs.ticketIssueTime,
       std::chrono::time_point<std::chrono::system_clock>(
           std::chrono::seconds(25)));
   EXPECT_EQ(*rs.alpn, "h2");
 }

fizz::server::test::TEST	(	TicketCodecTest	,
		TestDecodeWithoutAppToken
	)

Definition at line 210 of file TicketCodecTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::decode(), EXPECT_EQ, EXPECT_TRUE, ticketWithoutAppToken, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::test::toIOBuf().

                                                  {
   auto rs = TicketCodec<CertificateStorage::X509>::decode(
       toIOBuf(ticketWithoutAppToken), nullptr);
   EXPECT_EQ(rs.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(rs.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_TRUE(IOBufEqualTo()(rs.resumptionSecret, IOBuf::copyBuffer("secret")));
   EXPECT_EQ(rs.ticketAgeAdd, 0x44444444);
   EXPECT_EQ(
       rs.ticketIssueTime,
       std::chrono::time_point<std::chrono::system_clock>(
           std::chrono::seconds(25)));
   EXPECT_EQ(*rs.alpn, "h2");
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestNoMatchDefault
	)

Definition at line 42 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and string.

                                             {
   auto cert = getCert("blah.com", {}, kRsa);
   manager_.addCert(cert, true);
   auto res = manager_.getCert(std::string("test.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestNoSniDefault
	)

Definition at line 49 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and folly::none.

                                           {
   auto cert = getCert("blah.com", {}, kRsa);
   manager_.addCert(cert, true);
   auto res = manager_.getCert(none, kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestWildcardDefault
	)

Definition at line 56 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and folly::none.

                                              {
   auto cert = getCert("*.blah.com", {}, kRsa);
   manager_.addCert(cert, true);
   auto res = manager_.getCert(none, kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestBasic
	)

Definition at line 59 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::server::getCookieState(), testing::Invoke(), testing::InvokeWithoutArgs(), folly::gen::seq(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                       {
   auto mockHandshakeContext = new MockHandshakeContext();
   Sequence seq;
   EXPECT_CALL(
       factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(seq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext);
       }));
   EXPECT_CALL(
       *mockHandshakeContext,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(seq);
   EXPECT_CALL(*mockHandshakeContext, getHandshakeContext())
       .WillOnce(Invoke([]() { return IOBuf::copyBuffer("context"); }));
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_128_GCM_SHA256}},
       {NamedGroup::x25519},
       TestMessages::clientHello(),
       IOBuf::copyBuffer("token"));
   EXPECT_EQ(state.version, TestProtocolVersion);
   EXPECT_EQ(state.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state.group.hasValue());
   EXPECT_TRUE(IOBufEqualTo()(state.chloHash, IOBuf::copyBuffer("context")));
   EXPECT_TRUE(IOBufEqualTo()(state.appToken, IOBuf::copyBuffer("token")));
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestUppercaseDefault
	)

Definition at line 63 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and folly::none.

                                               {
   auto cert = getCert("BLAH.com", {}, kRsa);
   manager_.addCert(cert, true);
   auto res = manager_.getCert(none, kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestNoDefault
	)

Definition at line 70 of file CertManagerTest.cpp.

References EXPECT_FALSE, and string.

                                        {
   EXPECT_FALSE(manager_.getCert(std::string("blah.com"), {}, {}).hasValue());
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestGetRetry
	)

Definition at line 72 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::sm::getClientHello(), folly::hexlify(), folly::gen::move, retry, and fizz::test::useMockRandom().

                                            {
   useMockRandom();
   auto res = cipher_->getTokenOrRetry(
       getClientHello(nullptr), IOBuf::copyBuffer("test"));
   auto msg = std::move(boost::get<StatelessHelloRetryRequest>(res));
   EXPECT_EQ(hexlify(msg.data->coalesce()), retry);
 }

fizz::server::test::TEST_F	(	FizzServerTest	,
		TestAccept
	)

Definition at line 73 of file FizzServerTest.cpp.

References folly::netops::accept().

                                    {
   accept();
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestSigSchemesServerPref
	)

Definition at line 74 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), fizz::rsa_pss_sha256, fizz::rsa_pss_sha512, and string.

                                                   {
   auto cert = getCert(
       "www.test.com",
       {},
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512});
   manager_.addCert(cert);
 
   auto res = manager_.getCert(
       std::string("www.test.com"),
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512},
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512});
   EXPECT_EQ(res->first, cert);
   EXPECT_EQ(res->second, SignatureScheme::rsa_pss_sha256);
 
   res = manager_.getCert(
       std::string("www.test.com"),
       {SignatureScheme::rsa_pss_sha512, SignatureScheme::rsa_pss_sha256},
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512});
   EXPECT_EQ(res->first, cert);
   EXPECT_EQ(res->second, SignatureScheme::rsa_pss_sha512);
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestGetRetryGroup
	)

Definition at line 80 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::sm::getClientHello(), folly::hexlify(), folly::gen::move, retryGroup, fizz::secp256r1, and fizz::test::useMockRandom().

                                                 {
   useMockRandom();
   context_->setSupportedGroups({NamedGroup::secp256r1});
   auto res = cipher_->getTokenOrRetry(
       getClientHello(nullptr), IOBuf::copyBuffer("test"));
   auto msg = std::move(boost::get<StatelessHelloRetryRequest>(res));
   EXPECT_EQ(hexlify(msg.data->coalesce()), retryGroup);
 }

fizz::server::test::TEST_F	(	FizzServerTest	,
		TestSSLV2
	)

Definition at line 84 of file FizzServerTest.cpp.

References folly::netops::accept(), EXPECT_CALL, and getV2ClientHello().

                                   {
   context_->setVersionFallbackEnabled(true);
   accept();
   fizzServer_->queue_.append(getV2ClientHello());
   EXPECT_CALL(fizzServer_->visitor_, fallback());
   fizzServer_->fizzServer_.newTransportData();
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestNoVersion
	)

Definition at line 88 of file CookieCipherTest.cpp.

References chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_THROW, fizz::server::getCookieState(), fizz::test::TestMessages::removeExtension(), fizz::supported_versions, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                           {
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::supported_versions);
   EXPECT_THROW(
       getCookieState(
           factory_,
           {TestProtocolVersion},
           {{CipherSuite::TLS_AES_128_GCM_SHA256}},
           {NamedGroup::x25519},
           chlo,
           IOBuf::copyBuffer("token")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestGetToken
	)

Definition at line 89 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_TRUE, fizz::sm::getClientHello(), folly::gen::move, testCookie, and fizz::test::toIOBuf().

                                            {
   auto res = cipher_->getTokenOrRetry(
       getClientHello(toIOBuf(testCookie)), IOBuf::copyBuffer("xx"));
   auto token = std::move(boost::get<AppToken>(res));
   EXPECT_TRUE(IOBufEqualTo()(token.token, IOBuf::copyBuffer("test")));
 }

fizz::server::test::TEST_F	(	FizzServerTest	,
		TestSSLV2NoVersionFallback
	)

Definition at line 92 of file FizzServerTest.cpp.

References testing::_, folly::netops::accept(), EXPECT_CALL, getV2ClientHello(), and testing::InvokeWithoutArgs().

                                                    {
   context_->setVersionFallbackEnabled(false);
   accept();
   fizzServer_->queue_.append(getV2ClientHello());
   EXPECT_CALL(
       *MockServerStateMachineInstance::instance, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([this]() {
         fizzServer_->fizzServer_.waitForData();
         return AsyncActions(Actions());
       }));
   fizzServer_->fizzServer_.newTransportData();
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestGetJunk
	)

Definition at line 96 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), and EXPECT_THROW.

                                           {
   EXPECT_THROW(
       cipher_->getTokenOrRetry(
           IOBuf::copyBuffer("junk"), IOBuf::copyBuffer("test")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestClientSigScheme
	)

Definition at line 96 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), fizz::rsa_pss_sha256, fizz::rsa_pss_sha512, and string.

                                              {
   auto cert1 = getCert("www.test.com", {}, {SignatureScheme::rsa_pss_sha256});
   auto cert2 = getCert("www.test.com", {}, {SignatureScheme::rsa_pss_sha512});
   manager_.addCert(cert1);
   manager_.addCert(cert2);
 
   auto res = manager_.getCert(
       std::string("www.test.com"),
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512},
       {SignatureScheme::rsa_pss_sha512});
   EXPECT_EQ(res->first, cert2);
   EXPECT_EQ(res->second, SignatureScheme::rsa_pss_sha512);
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestVersionMismatch
	)

Definition at line 102 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_THROW, fizz::server::getCookieState(), fizz::tls_1_2, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                 {
   EXPECT_THROW(
       getCookieState(
           factory_,
           {ProtocolVersion::tls_1_2},
           {{CipherSuite::TLS_AES_128_GCM_SHA256}},
           {NamedGroup::x25519},
           TestMessages::clientHello(),
           IOBuf::copyBuffer("token")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestGetPartial
	)

Definition at line 103 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_THROW, fizz::sm::getClientHello(), folly::gen::move, testCookie, and fizz::test::toIOBuf().

                                              {
   auto trimmed = getClientHello(toIOBuf(testCookie));
   trimmed->coalesce();
   trimmed->trimEnd(1);
   EXPECT_THROW(
       cipher_->getTokenOrRetry(std::move(trimmed), IOBuf::copyBuffer("test")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	FizzServerTest	,
		TestNotSSLV2
	)

Definition at line 105 of file FizzServerTest.cpp.

References testing::_, folly::netops::accept(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                      {
   context_->setVersionFallbackEnabled(true);
   accept();
   fizzServer_->queue_.append(IOBuf::copyBuffer("ClientHello"));
   EXPECT_CALL(
       *MockServerStateMachineInstance::instance, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([this]() {
         fizzServer_->fizzServer_.waitForData();
         return AsyncActions(Actions());
       }));
   fizzServer_->fizzServer_.newTransportData();
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestClientSigSchemeWildcardMatch
	)

Definition at line 110 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), fizz::rsa_pss_sha256, fizz::rsa_pss_sha512, and string.

                                                           {
   auto cert1 = getCert("www.test.com", {}, {SignatureScheme::rsa_pss_sha256});
   auto cert2 = getCert("*.test.com", {}, {SignatureScheme::rsa_pss_sha512});
   manager_.addCert(cert1);
   manager_.addCert(cert2);
 
   auto res = manager_.getCert(
       std::string("www.test.com"),
       {SignatureScheme::rsa_pss_sha256, SignatureScheme::rsa_pss_sha512},
       {SignatureScheme::rsa_pss_sha512});
   EXPECT_EQ(res->first, cert2);
   EXPECT_EQ(res->second, SignatureScheme::rsa_pss_sha512);
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestDecrypt
	)

Definition at line 112 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_FALSE, EXPECT_TRUE, testCookie, and fizz::test::toIOBuf().

                                           {
   auto state = cipher_->decrypt(toIOBuf(testCookie));
   EXPECT_TRUE(state.hasValue());
   EXPECT_TRUE(IOBufEqualTo()(state->appToken, IOBuf::copyBuffer("test")));
   EXPECT_FALSE(state->group.hasValue());
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestCipherNegotiate
	)

Definition at line 114 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, fizz::server::getCookieState(), testing::InvokeWithoutArgs(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLS_AES_256_GCM_SHA384, and fizz::x25519.

                                                 {
   EXPECT_CALL(
       factory_, makeHandshakeContext(CipherSuite::TLS_AES_256_GCM_SHA384))
       .WillOnce(InvokeWithoutArgs([=]() {
         auto ret = std::make_unique<MockHandshakeContext>();
         ret->setDefaults();
         return ret;
       }));
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_256_GCM_SHA384},
        {CipherSuite::TLS_AES_128_GCM_SHA256}},
       {NamedGroup::x25519},
       TestMessages::clientHello(),
       IOBuf::copyBuffer("token"));
   EXPECT_EQ(state.cipher, CipherSuite::TLS_AES_256_GCM_SHA384);
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestEncryptNoTicketSecrets
	)

Definition at line 118 of file AeadTicketCipherTest.cpp.

                                                          {
   checkUnsetEncrypt();
 }

fizz::server::test::TEST_F	(	FizzServerTest	,
		TestSSLV2AfterData
	)

Definition at line 118 of file FizzServerTest.cpp.

References testing::_, folly::netops::accept(), folly::IOBuf::copyBuffer(), EXPECT_CALL, getV2ClientHello(), and testing::InvokeWithoutArgs().

                                            {
   context_->setVersionFallbackEnabled(true);
   accept();
   fizzServer_->queue_.append(IOBuf::copyBuffer("ClientHello"));
   EXPECT_CALL(
       *MockServerStateMachineInstance::instance, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([this]() {
         fizzServer_->fizzServer_.waitForData();
         return AsyncActions(Actions());
       }));
   fizzServer_->fizzServer_.newTransportData();
   fizzServer_->queue_.clear();
   fizzServer_->queue_.append(getV2ClientHello());
   EXPECT_CALL(
       *MockServerStateMachineInstance::instance, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([this]() {
         fizzServer_->fizzServer_.waitForData();
         return AsyncActions(Actions());
       }));
   fizzServer_->fizzServer_.newTransportData();
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestDecryptGroup
	)

Definition at line 119 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, EXPECT_TRUE, fizz::secp256r1, testCookieGroup, and fizz::test::toIOBuf().

                                                {
   auto state = cipher_->decrypt(toIOBuf(testCookieGroup));
   EXPECT_TRUE(state.hasValue());
   EXPECT_TRUE(IOBufEqualTo()(state->appToken, IOBuf::copyBuffer("test")));
   EXPECT_EQ(*state->group, NamedGroup::secp256r1);
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestEncrypt
	)

Definition at line 122 of file AeadTicketCipherTest.cpp.

References testing::_, codec_, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::InvokeWithoutArgs(), folly::gen::move, ticket1, fizz::test::toIOBuf(), and fizz::test::useMockRandom().

                                           {
   setTicketSecrets();
   useMockRandom();
   cipher_.setValidity(std::chrono::seconds(5));
   EXPECT_CALL(codec_, _encode(_)).WillOnce(InvokeWithoutArgs([]() {
     return IOBuf::copyBuffer("encodedticket");
   }));
   ResumptionState state;
   auto result = cipher_.encrypt(std::move(state)).get();
   EXPECT_TRUE(result.hasValue());
   EXPECT_TRUE(IOBufEqualTo()(result->first, toIOBuf(ticket1)));
   EXPECT_EQ(result->second, std::chrono::seconds(5));
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestClientSigSchemeFallback
	)

Definition at line 124 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), fizz::rsa_pss_sha256, fizz::rsa_pss_sha512, and string.

                                                      {
   auto cert = getCert("www.test.com", {}, {SignatureScheme::rsa_pss_sha256});
   manager_.addCert(cert);
 
   auto res = manager_.getCert(
       std::string("www.test.com"),
       {SignatureScheme::rsa_pss_sha256},
       {SignatureScheme::rsa_pss_sha512});
   EXPECT_EQ(res->first, cert);
   EXPECT_EQ(res->second, SignatureScheme::rsa_pss_sha256);
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestDecryptMultipleSecrets
	)

Definition at line 126 of file AeadCookieCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, folly::gen::range(), s, secret, testCookie, and fizz::test::toIOBuf().

                                                          {
   auto s = toIOBuf(secret);
   auto s1 = RandomGenerator<32>().generateRandom();
   auto s2 = RandomGenerator<32>().generateRandom();
   std::vector<ByteRange> cookieSecrets{{range(s1), range(s2), s->coalesce()}};
   EXPECT_TRUE(cipher_->setCookieSecrets(std::move(cookieSecrets)));
 
   auto state = cipher_->decrypt(toIOBuf(testCookie));
   EXPECT_TRUE(state.hasValue());
   EXPECT_TRUE(IOBufEqualTo()(state->appToken, IOBuf::copyBuffer("test")));
   EXPECT_FALSE(state->group.hasValue());
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestCipherNegotiateTie
	)

Definition at line 133 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, fizz::server::getCookieState(), testing::InvokeWithoutArgs(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLS_AES_256_GCM_SHA384, and fizz::x25519.

                                                    {
   EXPECT_CALL(
       factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         auto ret = std::make_unique<MockHandshakeContext>();
         ret->setDefaults();
         return ret;
       }));
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_256_GCM_SHA384,
         CipherSuite::TLS_AES_128_GCM_SHA256}},
       {NamedGroup::x25519},
       TestMessages::clientHello(),
       IOBuf::copyBuffer("token"));
   EXPECT_EQ(state.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestAccept
	)

Definition at line 134 of file AsyncFizzServerTest.cpp.

References folly::netops::accept().

                                         {
   accept();
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptNoTicketSecrets
	)

Definition at line 136 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, fizz::Rejected, ticket1, and fizz::test::toIOBuf().

                                                          {
   auto result = cipher_.decrypt(toIOBuf(ticket1)).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestAlts
	)

Definition at line 136 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and string.

                                   {
   auto cert = getCert(
       "www.test.com",
       {"www.test.com", "www.example.com", "*.example.com"},
       kRsa);
   manager_.addCert(cert);
 
   auto res = manager_.getCert(std::string("www.test.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 
   res = manager_.getCert(std::string("www.example.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 
   res = manager_.getCert(std::string("foo.example.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestReadSingle
	)

Definition at line 138 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                             {
   accept();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(WaitForData()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	AeadCookieCipherTest	,
		TestDecryptFailed
	)

Definition at line 139 of file AeadCookieCipherTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, folly::gen::range(), testCookie, and fizz::test::toIOBuf().

                                                 {
   auto s1 = RandomGenerator<32>().generateRandom();
   auto s2 = RandomGenerator<32>().generateRandom();
   std::vector<ByteRange> cookieSecrets{{range(s1), range(s2)}};
   EXPECT_TRUE(cipher_->setCookieSecrets(std::move(cookieSecrets)));
 
   auto state = cipher_->decrypt(toIOBuf(testCookie));
   EXPECT_FALSE(state.hasValue());
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptFirst
	)

Definition at line 142 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, fizz::Resumption, ticket1, and fizz::test::toIOBuf().

                                                {
   setTicketSecrets();
   expectDecode();
   auto result = cipher_.decrypt(toIOBuf(ticket1)).get();
   EXPECT_EQ(result.first, PskType::Resumption);
   EXPECT_TRUE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestReadMulti
	)

Definition at line 145 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                            {
   accept();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(); }))
       .WillOnce(InvokeWithoutArgs([]() { return actions(WaitForData()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptSecond
	)

Definition at line 150 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, fizz::Resumption, ticket3, and fizz::test::toIOBuf().

                                                 {
   setTicketSecrets();
   expectDecode();
   auto result = cipher_.decrypt(toIOBuf(ticket3)).get();
   EXPECT_EQ(result.first, PskType::Resumption);
   EXPECT_TRUE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestCipherMismatch
	)

Definition at line 152 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_THROW, fizz::server::getCookieState(), fizz::test::TestProtocolVersion, and fizz::x25519.

                                                {
   EXPECT_THROW(
       getCookieState(
           factory_,
           {TestProtocolVersion},
           {{}},
           {NamedGroup::x25519},
           TestMessages::clientHello(),
           IOBuf::copyBuffer("token")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestWrite
	)

Definition at line 153 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                        {
   accept();
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(); }));
   server_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestWildcard
	)

Definition at line 153 of file CertManagerTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, fizz::test::getCert(), kRsa, and string.

                                       {
   auto cert = getCert("*.test.com", {}, kRsa);
   manager_.addCert(cert);
 
   auto res = manager_.getCert(std::string("bar.test.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert);
 
   EXPECT_FALSE(
       manager_.getCert(std::string("foo.bar.test.com"), kRsa, kRsa).hasValue());
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptWithContext
	)

Definition at line 158 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, fizz::Resumption, ticket4, and fizz::test::toIOBuf().

                                                      {
   setTicketSecrets("foobar");
   expectDecode();
   auto result = cipher_.decrypt(toIOBuf(ticket4)).get();
   EXPECT_EQ(result.first, PskType::Resumption);
   EXPECT_TRUE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestWriteMulti
	)

Definition at line 160 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                             {
   accept();
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(); }));
   server_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(); }));
   server_->writeChain(nullptr, IOBuf::copyBuffer("HTTP POST"));
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestGroupNotSent
	)

Definition at line 164 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::server::getCookieState(), fizz::secp256r1, fizz::test::TestProtocolVersion, and fizz::TLS_AES_128_GCM_SHA256.

                                              {
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_128_GCM_SHA256}},
       {NamedGroup::secp256r1},
       TestMessages::clientHello(),
       IOBuf::copyBuffer("token"));
   EXPECT_EQ(*state.group, NamedGroup::secp256r1);
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestExactMatch
	)

Definition at line 164 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), kRsa, and string.

                                         {
   auto cert1 = getCert("*.test.com", {}, kRsa);
   auto cert2 = getCert("foo.test.com", {}, kRsa);
   manager_.addCert(cert1);
   manager_.addCert(cert2);
 
   auto res = manager_.getCert(std::string("foo.test.com"), kRsa, kRsa);
   EXPECT_EQ(res->first, cert2);
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptWithoutContext
	)

Definition at line 166 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, fizz::Rejected, ticket4, and fizz::test::toIOBuf().

                                                         {
   setTicketSecrets();
   // Ticket 4 needs context 'foobar'
   auto result = cipher_.decrypt(toIOBuf(ticket4)).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestWriteErrorState
	)

Definition at line 170 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), folly::IOBuf::copyBuffer(), folly::pushmi::operators::error(), EXPECT_CALL, ON_CALL, testing::Return(), and socket_.

                                                  {
   accept();
   ON_CALL(*socket_, error()).WillByDefault(Return(true));
   EXPECT_CALL(writeCallback_, writeErr_(0, _));
   server_->writeChain(&writeCallback_, IOBuf::copyBuffer("test"));
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestNoWildcard
	)

Definition at line 174 of file CertManagerTest.cpp.

References EXPECT_FALSE, fizz::test::getCert(), kRsa, and string.

                                         {
   auto cert = getCert("foo.test.com", {}, kRsa);
   manager_.addCert(cert);
 
   EXPECT_FALSE(
       manager_.getCert(std::string("blah.test.com"), kRsa, kRsa).hasValue());
   EXPECT_FALSE(
       manager_.getCert(std::string("test.com"), kRsa, kRsa).hasValue());
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptWithWrongContext
	)

Definition at line 174 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, fizz::Rejected, ticket4, and fizz::test::toIOBuf().

                                                           {
   setTicketSecrets("barbaz");
   // barbaz =/= foobar
   auto result = cipher_.decrypt(toIOBuf(ticket4)).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestNoGroups
	)

Definition at line 175 of file CookieCipherTest.cpp.

References chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_FALSE, fizz::server::getCookieState(), fizz::key_share, fizz::test::TestMessages::removeExtension(), fizz::supported_groups, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                          {
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::supported_groups);
   TestMessages::removeExtension(chlo, ExtensionType::key_share);
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_128_GCM_SHA256}},
       {NamedGroup::x25519},
       chlo,
       IOBuf::copyBuffer("token"));
   EXPECT_FALSE(state.group.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestHandshake
	)

Definition at line 177 of file AsyncFizzServerTest.cpp.

                                            {
   completeHandshake();
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestExporterAPISimple
	)

Definition at line 181 of file AsyncFizzServerTest.cpp.

References fizz::extensions::kTokenBindingExporterLabel.

                                                    {
   completeHandshake();
   server_->getEkm(kTokenBindingExporterLabel, nullptr, 32);
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptWithUnneededContext
	)

Definition at line 182 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, fizz::Rejected, ticket3, and fizz::test::toIOBuf().

                                                              {
   setTicketSecrets("foobar");
   // Now test that ticket 3 with context 'foobar' doesn't work
   auto result = cipher_.decrypt(toIOBuf(ticket3)).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	CertManagerTest	,
		TestGetByIdentity
	)

Definition at line 184 of file CertManagerTest.cpp.

References EXPECT_EQ, fizz::test::getCert(), and kRsa.

                                            {
   auto cert = getCert("*.test.com", {"www.example.com"}, kRsa);
   manager_.addCert(cert);
 
   EXPECT_EQ(manager_.getCert("*.test.com"), cert);
   EXPECT_EQ(manager_.getCert("www.example.com"), nullptr);
   EXPECT_EQ(manager_.getCert("foo.test.com"), nullptr);
   EXPECT_EQ(manager_.getCert("www.blah.com"), nullptr);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestExporterAPIIncompleteHandshake
	)

Definition at line 186 of file AsyncFizzServerTest.cpp.

References EXPECT_THROW, and fizz::extensions::kTokenBindingExporterLabel.

                                                                 {
   EXPECT_THROW(
       server_->getEkm(kTokenBindingExporterLabel, nullptr, 32),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestNoKeyShare
	)

Definition at line 189 of file CookieCipherTest.cpp.

References chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_THROW, fizz::server::getCookieState(), fizz::key_share, fizz::test::TestMessages::removeExtension(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                            {
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::key_share);
   EXPECT_THROW(
       getCookieState(
           factory_,
           {TestProtocolVersion},
           {{CipherSuite::TLS_AES_128_GCM_SHA256}},
           {NamedGroup::x25519},
           chlo,
           IOBuf::copyBuffer("token")),
       std::runtime_error);
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptSeqNum
	)

Definition at line 190 of file AeadTicketCipherTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, fizz::Resumption, ticket2, and fizz::test::toIOBuf().

                                                 {
   setTicketSecrets();
   expectDecode();
   auto result = cipher_.decrypt(toIOBuf(ticket2)).get();
   EXPECT_EQ(result.first, PskType::Resumption);
   EXPECT_TRUE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestHandshakeError
	)

Definition at line 192 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                 {
   accept();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return actions(ReportError("unit test"), WaitForData()); }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptFailed
	)

Definition at line 198 of file AeadTicketCipherTest.cpp.

References badTicket, EXPECT_EQ, EXPECT_FALSE, fizz::Rejected, and fizz::test::toIOBuf().

                                                 {
   setTicketSecrets();
   auto result = cipher_.decrypt(toIOBuf(badTicket)).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestDeliverAppData
	)

Definition at line 201 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                 {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return actions(DeliverAppData{IOBuf::copyBuffer("HI")}, WaitForData());
       }));
   EXPECT_CALL(readCallback_, readBufferAvailable_(_));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	GetCookieStateTest	,
		TestGroupMismatch
	)

Definition at line 203 of file CookieCipherTest.cpp.

References fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_FALSE, fizz::server::getCookieState(), fizz::test::TestProtocolVersion, and fizz::TLS_AES_128_GCM_SHA256.

                                               {
   auto state = getCookieState(
       factory_,
       {TestProtocolVersion},
       {{CipherSuite::TLS_AES_128_GCM_SHA256}},
       {},
       TestMessages::clientHello(),
       IOBuf::copyBuffer("token"));
   EXPECT_FALSE(state.group.hasValue());
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestDecryptTooShort
	)

Definition at line 205 of file AeadTicketCipherTest.cpp.

References folly::IOBuf::copyBuffer(), EXPECT_EQ, EXPECT_FALSE, and fizz::Rejected.

                                                   {
   setTicketSecrets();
   auto result = cipher_.decrypt(IOBuf::copyBuffer("short")).get();
   EXPECT_EQ(result.first, PskType::Rejected);
   EXPECT_FALSE(result.second.hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestWriteToSocket
	)

Definition at line 212 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), fizz::application_data, fizz::AppTraffic, fizz::WriteToSocket::contents, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, testing::InvokeWithoutArgs(), folly::gen::move, socket_, and fizz::detail::write().

                                                {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         WriteToSocket write;
         TLSContent record;
         record.contentType = ContentType::application_data;
         record.encryptionLevel = EncryptionLevel::AppTraffic;
         record.data = IOBuf::copyBuffer("XYZ");
         write.contents.emplace_back(std::move(record));
         return actions(std::move(write), WaitForData());
       }));
   EXPECT_CALL(*socket_, writeChain(_, _, _));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestUnsetTicketSecrets
	)

Definition at line 212 of file AeadTicketCipherTest.cpp.

References EXPECT_TRUE.

                                                      {
   setTicketSecrets();
   EXPECT_TRUE(cipher_.setTicketSecrets(std::vector<ByteRange>()));
   checkUnsetEncrypt();
 }

fizz::server::test::TEST_F	(	AeadTicketCipherTest	,
		TestSetTicketSecretsTooShort
	)

Definition at line 218 of file AeadTicketCipherTest.cpp.

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

                                                            {
   StringPiece tooShort{"short"};
   std::vector<ByteRange> ticketSecrets{{tooShort}};
   EXPECT_FALSE(cipher_.setTicketSecrets(std::move(ticketSecrets)));
   checkUnsetEncrypt();
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestMutateState
	)

Definition at line 229 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), folly::IOBuf::copyBuffer(), fizz::server::Error, EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), fizz::server::State::state(), and uint32_t.

                                              {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   uint32_t numTimesRun = 0;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([&numTimesRun]() {
         return actions(
             [&numTimesRun](State& newState) {
               numTimesRun++;
               newState.state() = StateEnum::Error;
             },
             WaitForData());
       }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
   EXPECT_EQ(server_->getState().state(), StateEnum::Error);
   EXPECT_EQ(numTimesRun, 1);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestAttemptVersionFallback
	)

Definition at line 247 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), fizz::server::Error, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), testing::InvokeWithoutArgs(), and fizz::server::State::state().

                                                         {
   accept();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return actions(
             [](State& newState) { newState.state() = StateEnum::Error; },
             AttemptVersionFallback{IOBuf::copyBuffer("ClientHello")});
       }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeAttemptFallback(_))
       .WillOnce(Invoke([&](std::unique_ptr<IOBuf>& clientHello) {
         // The mock machine does not move the read buffer so there will be a 2nd
         // ClientHello.
         EXPECT_TRUE(IOBufEqualTo()(
             clientHello, IOBuf::copyBuffer("ClientHelloClientHello")));
         server_.reset();
       }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestDeleteAsyncEvent
	)

Definition at line 266 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), fizz::server::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), and folly::Promise< T >::setValue().

                                                   {
   accept();
   Promise<Actions> p1;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([&p1]() { return AsyncActions(p1.getFuture()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
   server_.reset();
   Promise<Actions> p2;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([&p2]() { return AsyncActions(p2.getFuture()); }));
   p1.setValue(detail::actions());
   p2.setValue(detail::actions(WaitForData()));
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestCloseHandshake
	)

Definition at line 282 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), testing::AtLeast(), EXPECT_CALL, and socket_.

                                                 {
   accept();
   expectAppClose();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   server_->closeNow();
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestCloseNowInFlightAction
	)

Definition at line 290 of file AsyncFizzServerTest.cpp.

References testing::_, fizz::server::detail::actions(), testing::AtLeast(), folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), folly::Promise< T >::setValue(), and socket_.

                                                         {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   Promise<Actions> p;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([&p]() { return AsyncActions(p.getFuture()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   server_->writeChain(&writeCallback_, IOBuf::copyBuffer("queued write"));
   EXPECT_CALL(writeCallback_, writeErr_(0, _));
   EXPECT_CALL(readCallback_, readEOF_());
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   server_->closeNow();
   p.setValue(detail::actions(WaitForData()));
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestCloseInFlightAction
	)

Definition at line 306 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), fizz::server::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, folly::Promise< T >::getFuture(), testing::InvokeWithoutArgs(), and folly::Promise< T >::setValue().

                                                      {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   Promise<Actions> p;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([&p]() { return AsyncActions(p.getFuture()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   server_->writeChain(&writeCallback_, IOBuf::copyBuffer("queued write"));
   server_->close();
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return actions(); }));
   expectAppClose();
   p.setValue(detail::actions(WaitForData()));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestInvalidTransitionNoAlert
	)

Definition at line 307 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), and folly::none.

                                                          {
   auto actions =
       getActions(ServerStateMachine().processAppWrite(state_, AppWrite()));
   expectError<FizzException>(actions, none, "invalid event");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestInvalidTransitionAlert
	)

Definition at line 313 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), EXPECT_CALL, and fizz::unexpected_message.

                                                        {
   setMockRecord();
   EXPECT_CALL(*mockWrite_, _write(_));
   auto actions =
       getActions(ServerStateMachine().processAppWrite(state_, AppWrite()));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "invalid event");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestInvalidTransitionError
	)

Definition at line 322 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::Error, and EXPECT_TRUE.

                                                        {
   state_.state() = StateEnum::Error;
   auto actions =
       getActions(ServerStateMachine().processAppWrite(state_, AppWrite()));
   EXPECT_TRUE(actions.empty());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestIsDetachable
	)

Definition at line 323 of file AsyncFizzServerTest.cpp.

References testing::_, fizz::server::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), ON_CALL, testing::Return(), and socket_.

                                               {
   completeHandshake();
   AsyncTransportWrapper::ReadCallback* readCb = socketReadCallback_;
   ON_CALL(*socket_, isDetachable()).WillByDefault(Return(false));
   EXPECT_FALSE(server_->isDetachable());
   ON_CALL(*socket_, isDetachable()).WillByDefault(Return(true));
   EXPECT_TRUE(server_->isDetachable());
   Promise<Actions> p;
 
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([&p]() { return AsyncActions(p.getFuture()); }));
   socket_->setReadCB(readCb);
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   EXPECT_FALSE(server_->isDetachable());
   p.setValue(detail::actions(WaitForData()));
   EXPECT_TRUE(server_->isDetachable());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAlertReceived
	)

Definition at line 329 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::alert, fizz::Alert::description, folly::gen::move, folly::none, fizz::client::detail::processEvent(), and fizz::unexpected_message.

                                               {
   setUpAcceptingData();
   Alert alert;
   alert.description = AlertDescription::unexpected_message;
   auto actions = getActions(detail::processEvent(state_, std::move(alert)));
   expectError<FizzException>(actions, folly::none, "received alert");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAccept
	)

Definition at line 337 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, EXPECT_EQ, testing::Invoke(), and fizz::Plaintext.

                                        {
   ReadRecordLayer* rrl;
   WriteRecordLayer* wrl;
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke([&rrl]() {
         auto ret = std::make_unique<PlaintextReadRecordLayer>();
         rrl = ret.get();
         return ret;
       }));
   EXPECT_CALL(*factory_, makePlaintextWriteRecordLayer())
       .WillOnce(Invoke([&wrl]() {
         auto ret = std::make_unique<PlaintextWriteRecordLayer>();
         wrl = ret.get();
         return ret;
       }));
   auto actions = getActions(ServerStateMachine().processAccept(
       state_, &executor_, context_, extensions_));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingClientHello);
   EXPECT_EQ(state_.executor(), &executor_);
   EXPECT_EQ(state_.context().get(), context_.get());
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestConnecting
	)

Definition at line 342 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), ON_CALL, testing::Return(), and socket_.

                                             {
   ON_CALL(*socket_, connecting()).WillByDefault(Return(true));
   EXPECT_TRUE(server_->connecting());
   ON_CALL(*socket_, connecting()).WillByDefault(Return(false));
   accept();
   EXPECT_TRUE(server_->connecting());
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return actions(ReportHandshakeSuccess(), WaitForData()); }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
   EXPECT_FALSE(server_->connecting());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestGoodSocket
	)

Definition at line 356 of file AsyncFizzServerTest.cpp.

References folly::netops::accept(), EXPECT_FALSE, EXPECT_TRUE, ON_CALL, testing::Return(), and socket_.

                                             {
   accept();
   ON_CALL(*socket_, good()).WillByDefault(Return(true));
   EXPECT_TRUE(server_->good());
   ON_CALL(*socket_, good()).WillByDefault(Return(false));
   EXPECT_FALSE(server_->good());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestGoodState
	)

Definition at line 364 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), folly::IOBuf::copyBuffer(), fizz::server::Error, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), ON_CALL, testing::Return(), socket_, and fizz::server::State::state().

                                            {
   completeHandshake();
   ON_CALL(*socket_, good()).WillByDefault(Return(true));
   EXPECT_TRUE(server_->good());
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return actions(
             [](State& newState) { newState.state() = StateEnum::Error; });
       }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   EXPECT_FALSE(server_->good());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAppClose
	)

Definition at line 369 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::alert, fizz::AppTraffic, fizz::close_notify, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encode(), fizz::TLSContent::encryptionLevel, fizz::test::Error, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), fizz::server::ServerStateMachine::processAppClose(), fizz::TLSMessage::type, and fizz::detail::write().

                                          {
   setUpAcceptingData();
   EXPECT_CALL(*appWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = appWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::alert);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encode(Alert(AlertDescription::close_notify))));
     content.data = IOBuf::copyBuffer("closenotify");
     return content;
   }));
   auto actions = ServerStateMachine().processAppClose(state_);
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents[0].contentType, ContentType::alert);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::AppTraffic);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Error);
   EXPECT_EQ(state_.readRecordLayer().get(), nullptr);
   EXPECT_EQ(state_.writeRecordLayer().get(), nullptr);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestEarlySuccess
	)

Definition at line 377 of file AsyncFizzServerTest.cpp.

References testing::_, folly::netops::accept(), actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                               {
   accept();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return actions(ReportEarlyHandshakeSuccess(), WaitForData());
       }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 
   fullHandshakeSuccess();
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestErrorStopsActions
	)

Definition at line 389 of file AsyncFizzServerTest.cpp.

References testing::_, actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, and testing::InvokeWithoutArgs().

                                                    {
   completeHandshake();
   server_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return actions(ReportError("unit test")); }));
   EXPECT_FALSE(server_->error());
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   EXPECT_TRUE(server_->error());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAppCloseNoWrite
	)

Definition at line 392 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::Error, EXPECT_EQ, and fizz::server::ServerStateMachine::processAppClose().

                                                 {
   auto actions = ServerStateMachine().processAppClose(state_);
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Error);
   EXPECT_EQ(state_.readRecordLayer().get(), nullptr);
   EXPECT_EQ(state_.writeRecordLayer().get(), nullptr);
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestGetCertsNone
	)

Definition at line 400 of file AsyncFizzServerTest.cpp.

References EXPECT_EQ.

                                               {
   completeHandshake();
   EXPECT_EQ(server_->getSelfCert(), nullptr);
   EXPECT_EQ(server_->getPeerCert(), nullptr);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloFullHandshakeFlow
	)

Definition at line 401 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, ASSERT_EQ, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::certificateVerify(), fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHello(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::ecdsa_secp256r1_sha256, fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::test::getCert(), fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::server::NotChecked, fizz::OneRtt, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::rsa_pss_sha256, fizz::Server, fizz::ServerAppTraffic, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), sni, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::token_binding, fizz::TLSMessage::type, fizz::detail::write(), and fizz::x25519.

                                                              {
   setUpExpectingClientHello();
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::serverHello())));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   EXPECT_CALL(*extensions_, getExtensions(_)).WillOnce(InvokeWithoutArgs([]() {
     Extension ext;
     ext.extension_type = ExtensionType::token_binding;
     ext.extension_data = folly::IOBuf::copyBuffer("someextension");
     std::vector<Extension> exts;
     exts.push_back(std::move(ext));
     return exts;
   }));
 
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
 
         auto modifiedEncryptedExt = TestMessages::encryptedExt();
         Extension ext;
         ext.extension_type = ExtensionType::token_binding;
         ext.extension_data = folly::IOBuf::copyBuffer("someextension");
         modifiedEncryptedExt.extensions.push_back(std::move(ext));
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 std::move(modifiedEncryptedExt),
                 TestMessages::certificate(),
                 TestMessages::certificateVerify(),
                 TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*certManager_, getCert(_, _, _))
       .WillOnce(Invoke(
           [=](const folly::Optional<std::string>& sni,
               const std::vector<SignatureScheme>& /* supportedSigSchemes */,
               const std::vector<SignatureScheme>& peerSigSchemes) {
             EXPECT_EQ(*sni, "www.hostname.com");
             EXPECT_EQ(peerSigSchemes.size(), 2);
             EXPECT_EQ(
                 peerSigSchemes[0], SignatureScheme::ecdsa_secp256r1_sha256);
             EXPECT_EQ(peerSigSchemes[1], SignatureScheme::rsa_pss_sha256);
             return CertManager::CertMatch(
                 std::make_pair(cert_, SignatureScheme::ecdsa_secp256r1_sha256));
           }));
   EXPECT_CALL(*cert_, _getCertMessage(_));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("chlo_shlo_ee_cert"); }));
   EXPECT_CALL(
       *cert_,
       sign(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("chlo_shlo_ee_cert")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("signature"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_ee_cert_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           MasterSecrets::ExporterMaster,
           RangeMatches("chlo_shlo_ee_cert_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_ee_cert_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
 
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_EQ(state_.sigScheme(), SignatureScheme::ecdsa_secp256r1_sha256);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_FALSE(state_.pskMode().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_FALSE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	AsyncFizzServerTest	,
		TestGetCerts
	)

Definition at line 406 of file AsyncFizzServerTest.cpp.

References folly::netops::accept(), clientCert, EXPECT_CALL, EXPECT_EQ, and serverCert.

                                           {
   auto clientCert = std::make_shared<MockCert>();
   auto serverCert = std::make_shared<MockCert>();
   accept();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   fullHandshakeSuccess(clientCert, serverCert);
   EXPECT_CALL(*serverCert, getX509());
   EXPECT_EQ(server_->getSelfCert(), nullptr);
   EXPECT_CALL(*clientCert, getX509());
   EXPECT_EQ(server_->getPeerCert(), nullptr);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCompressedCertFlow
	)

Definition at line 637 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::CertificateCompressionAlgorithms::algorithms, ASSERT_EQ, fizz::test::TestMessages::certificateVerify(), chlo, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHello(), fizz::test::TestMessages::compressedCertificate(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::ecdsa_secp256r1_sha256, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::test::getCert(), fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::server::NotChecked, fizz::OneRtt, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::rsa_pss_sha256, fizz::Server, fizz::ServerAppTraffic, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), sni, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::token_binding, fizz::TLSMessage::type, fizz::detail::write(), fizz::x25519, and fizz::zlib.

                                                               {
   setUpExpectingClientHello();
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::serverHello())));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   EXPECT_CALL(*extensions_, getExtensions(_)).WillOnce(InvokeWithoutArgs([]() {
     Extension ext;
     ext.extension_type = ExtensionType::token_binding;
     ext.extension_data = folly::IOBuf::copyBuffer("someextension");
     std::vector<Extension> exts;
     exts.push_back(std::move(ext));
     return exts;
   }));
 
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
 
         auto modifiedEncryptedExt = TestMessages::encryptedExt();
         Extension ext;
         ext.extension_type = ExtensionType::token_binding;
         ext.extension_data = folly::IOBuf::copyBuffer("someextension");
         modifiedEncryptedExt.extensions.push_back(std::move(ext));
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 std::move(modifiedEncryptedExt),
                 TestMessages::compressedCertificate(),
                 TestMessages::certificateVerify(),
                 TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*certManager_, getCert(_, _, _))
       .WillOnce(Invoke(
           [=](const folly::Optional<std::string>& sni,
               const std::vector<SignatureScheme>& /* supportedSigSchemes */,
               const std::vector<SignatureScheme>& peerSigSchemes) {
             EXPECT_EQ(*sni, "www.hostname.com");
             EXPECT_EQ(peerSigSchemes.size(), 2);
             EXPECT_EQ(
                 peerSigSchemes[0], SignatureScheme::ecdsa_secp256r1_sha256);
             EXPECT_EQ(peerSigSchemes[1], SignatureScheme::rsa_pss_sha256);
             return CertManager::CertMatch(
                 std::make_pair(cert_, SignatureScheme::ecdsa_secp256r1_sha256));
           }));
   context_->setSupportedCompressionAlgorithms(
       {CertificateCompressionAlgorithm::zlib});
   EXPECT_CALL(*cert_, getCompressedCert(_)).WillOnce(InvokeWithoutArgs([]() {
     return TestMessages::compressedCertificate();
   }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("chlo_shlo_ee_compcert"); }));
   EXPECT_CALL(
       *cert_,
       sign(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("chlo_shlo_ee_compcert")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("signature"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_ee_compcert_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           MasterSecrets::ExporterMaster,
           RangeMatches("chlo_shlo_ee_compcert_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_ee_compcert_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto chlo = TestMessages::clientHello();
   CertificateCompressionAlgorithms algos;
   algos.algorithms = {CertificateCompressionAlgorithm::zlib};
   chlo.extensions.push_back(encodeExtension(algos));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
 
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.serverCertCompAlgo(), CertificateCompressionAlgorithm::zlib);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_EQ(state_.sigScheme(), SignatureScheme::ecdsa_secp256r1_sha256);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_FALSE(state_.pskMode().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_FALSE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCertRequestFlow
	)

Definition at line 875 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), ASSERT_EQ, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::certificateRequest(), fizz::test::TestMessages::certificateVerify(), fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHello(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::ecdsa_secp256r1_sha256, fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::test::getCert(), fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::server::NotChecked, fizz::OneRtt, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::rsa_pss_sha256, fizz::Server, fizz::ServerAppTraffic, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), sni, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::token_binding, fizz::TLSMessage::type, fizz::detail::write(), and fizz::x25519.

                                                            {
   setUpExpectingClientHello();
   context_->setClientAuthMode(ClientAuthMode::Required);
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::serverHello())));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   EXPECT_CALL(*extensions_, getExtensions(_)).WillOnce(InvokeWithoutArgs([]() {
     Extension ext;
     ext.extension_type = ExtensionType::token_binding;
     ext.extension_data = folly::IOBuf::copyBuffer("someextension");
     std::vector<Extension> exts;
     exts.push_back(std::move(ext));
     return exts;
   }));
 
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         auto modifiedEncryptedExt = TestMessages::encryptedExt();
         Extension ext;
         ext.extension_type = ExtensionType::token_binding;
         ext.extension_data = folly::IOBuf::copyBuffer("someextension");
         modifiedEncryptedExt.extensions.push_back(std::move(ext));
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 std::move(modifiedEncryptedExt),
                 TestMessages::certificateRequest(),
                 TestMessages::certificate(),
                 TestMessages::certificateVerify(),
                 TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*certManager_, getCert(_, _, _))
       .WillOnce(Invoke(
           [=](const folly::Optional<std::string>& sni,
               const std::vector<SignatureScheme>& /* supportedSigSchemes */,
               const std::vector<SignatureScheme>& peerSigSchemes) {
             EXPECT_EQ(*sni, "www.hostname.com");
             EXPECT_EQ(peerSigSchemes.size(), 2);
             EXPECT_EQ(
                 peerSigSchemes[0], SignatureScheme::ecdsa_secp256r1_sha256);
             EXPECT_EQ(peerSigSchemes[1], SignatureScheme::rsa_pss_sha256);
             return CertManager::CertMatch(
                 std::make_pair(cert_, SignatureScheme::ecdsa_secp256r1_sha256));
           }));
   EXPECT_CALL(*cert_, _getCertMessage(_));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("chlo_shlo_ee_cert"); }));
   EXPECT_CALL(
       *cert_,
       sign(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("chlo_shlo_ee_cert")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("signature"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_ee_cert_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           MasterSecrets::ExporterMaster,
           RangeMatches("chlo_shlo_ee_cert_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_ee_cert_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_EQ(state_.sigScheme(), SignatureScheme::ecdsa_secp256r1_sha256);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_FALSE(state_.pskMode().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_FALSE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskFlow
	)

Definition at line 1107 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, ASSERT_EQ, fizz::server::ResumptionState::cipher, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHelloPsk(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::key_share, makeRandom(), folly::gen::move, fizz::None, fizz::NotAttempted, fizz::server::NotChecked, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::psk_ke, random(), fizz::test::TestMessages::removeExtension(), fizz::Resumption, fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, fizz::ServerPresharedKey::selected_identity, fizz::ServerAppTraffic, fizz::server::ResumptionState::serverCert, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, and fizz::detail::write().

                                                    {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
   setUpExpectingClientHello();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.serverCert = cert_;
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumesecret")));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("client")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bdr")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("helloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ResumptionPskBinder, RangeMatches("")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'd', 'r'});
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveHandshakeSecret());
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto shlo = TestMessages::serverHello();
     TestMessages::removeExtension(shlo, ExtensionType::key_share);
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = 0;
     shlo.extensions.push_back(encodeExtension(std::move(serverPsk)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(shlo))));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExt(), TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("chlo_shlo_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_FALSE(state_.sigScheme().hasValue());
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.pskMode(), PskKeyExchangeMode::psk_ke);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::None);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_TRUE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskDheFlow
	)

Definition at line 1305 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, ASSERT_EQ, fizz::server::ResumptionState::cipher, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHelloPsk(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::server::NotChecked, fizz::OneRtt, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::psk_dhe_ke, random(), fizz::Resumption, fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, fizz::ServerPresharedKey::selected_identity, fizz::ServerAppTraffic, fizz::server::ResumptionState::serverCert, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, fizz::detail::write(), and fizz::x25519.

                                                       {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_dhe_ke});
   setUpExpectingClientHello();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.serverCert = cert_;
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumesecret")));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("client")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bdr")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("helloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ResumptionPskBinder, RangeMatches("")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'd', 'r'});
       }));
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto shlo = TestMessages::serverHello();
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = 0;
     shlo.extensions.push_back(encodeExtension(std::move(serverPsk)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(shlo))));
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExt(), TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("chlo_shlo_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_FALSE(state_.sigScheme().hasValue());
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.pskMode(), PskKeyExchangeMode::psk_dhe_ke);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_TRUE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloHelloRetryRequestFlow
	)

Definition at line 1515 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), ASSERT_EQ, fizz::test::TestMessages::clientHello(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::TLSMessage::fragment, fizz::handshake, fizz::HelloRetryRequest, fizz::test::TestMessages::helloRetryRequest(), testing::Invoke(), testing::InvokeWithoutArgs(), fizz::NotAttempted, fizz::server::NotChecked, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::secp256r1, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::detail::write(), and fizz::x25519.

                                                                  {
   setUpExpectingClientHello();
   auto firstHandshakeContext = new MockHandshakeContext();
   Sequence firstContextSeq;
   Sequence factorySeq;
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(factorySeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(firstHandshakeContext);
       }));
   EXPECT_CALL(
       *firstHandshakeContext,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(firstContextSeq);
   EXPECT_CALL(*firstHandshakeContext, getHandshakeContext())
       .InSequence(firstContextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_hash"); }));
   auto secondHandshakeContext = new MockHandshakeContext();
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(factorySeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(secondHandshakeContext);
       }));
   EXPECT_CALL(*secondHandshakeContext, appendToTranscript(_)).Times(2);
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::helloRetryRequest())));
     content.data = IOBuf::copyBuffer("writtenhrr");
     return content;
   }));
   auto newRrl = new MockPlaintextReadRecordLayer();
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke([newRrl]() {
         return std::unique_ptr<PlaintextReadRecordLayer>(newRrl);
       }));
   EXPECT_CALL(*newRrl, setSkipEncryptedRecords(false));
 
   context_->setSupportedGroups({NamedGroup::secp256r1, NamedGroup::x25519});
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 1);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenhrr")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingClientHello);
   EXPECT_EQ(state_.readRecordLayer().get(), newRrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.handshakeContext().get(), secondHandshakeContext);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::secp256r1);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestRetryClientHelloFullHandshakeFlow
	)

Definition at line 1589 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), ASSERT_EQ, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::certificateVerify(), fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHello(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::ecdsa_secp256r1_sha256, fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::test::getCert(), fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, fizz::HelloRetryRequest, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), fizz::NotAttempted, fizz::server::NotChecked, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::rsa_pss_sha256, fizz::Server, fizz::ServerAppTraffic, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), sni, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::detail::write(), and fizz::x25519.

                                                                   {
   setUpExpectingClientHelloRetry();
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("clienthelloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::serverHello())));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExt(),
                 TestMessages::certificate(),
                 TestMessages::certificateVerify(),
                 TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*certManager_, getCert(_, _, _))
       .WillOnce(Invoke(
           [=](const folly::Optional<std::string>& sni,
               const std::vector<SignatureScheme>& /* supportedSigSchemes */,
               const std::vector<SignatureScheme>& peerSigSchemes) {
             EXPECT_EQ(*sni, "www.hostname.com");
             EXPECT_EQ(peerSigSchemes.size(), 2);
             EXPECT_EQ(
                 peerSigSchemes[0], SignatureScheme::ecdsa_secp256r1_sha256);
             EXPECT_EQ(peerSigSchemes[1], SignatureScheme::rsa_pss_sha256);
             return CertManager::CertMatch(
                 std::make_pair(cert_, SignatureScheme::ecdsa_secp256r1_sha256));
           }));
   EXPECT_CALL(*cert_, _getCertMessage(_));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("chlo_shlo_ee_cert"); }));
   EXPECT_CALL(
       *cert_,
       sign(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("chlo_shlo_ee_cert")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("signature"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_ee_cert_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           MasterSecrets::ExporterMaster,
           RangeMatches("chlo_shlo_ee_cert_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_ee_cert_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_EQ(state_.sigScheme(), SignatureScheme::ecdsa_secp256r1_sha256);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_FALSE(state_.pskMode().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_FALSE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestRetryClientHelloPskDheFlow
	)

Definition at line 1797 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), ASSERT_EQ, fizz::server::ResumptionState::cipher, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHelloPsk(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExt(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, fizz::HelloRetryRequest, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::server::NotChecked, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::psk_dhe_ke, random(), fizz::Resumption, fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, fizz::ServerPresharedKey::selected_identity, fizz::ServerAppTraffic, fizz::server::ResumptionState::serverCert, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, fizz::detail::write(), and fizz::x25519.

                                                            {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_dhe_ke});
   setUpExpectingClientHelloRetry();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.serverCert = cert_;
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumesecret")));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("client")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bdr")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("helloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ResumptionPskBinder, RangeMatches("")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'd', 'r'});
       }));
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto shlo = TestMessages::serverHello();
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = 0;
     shlo.extensions.push_back(encodeExtension(std::move(serverPsk)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(shlo))));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   expectEncryptedReadRecordLayerCreation(
       &rrl, &raead, StringPiece("cht"), false);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExt(), TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("chlo_shlo_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_FALSE(state_.sigScheme().hasValue());
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.pskMode(), PskKeyExchangeMode::psk_dhe_ke);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotChecked);
   EXPECT_TRUE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskDheEarlyFlow
	)

Definition at line 1995 of file ServerProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::AppTraffic, ASSERT_EQ, fizz::server::ResumptionState::cipher, fizz::ClientEarlyTraffic, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHelloPskEarly(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::EarlyData, fizz::EarlyExporter, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExtEarly(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, folly::none, fizz::server::NotReplay, now(), fizz::OneRtt, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::psk_dhe_ke, random(), fizz::Resumption, fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, fizz::ServerPresharedKey::selected_identity, fizz::ServerAppTraffic, fizz::server::ResumptionState::serverCert, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, fizz::detail::write(), and fizz::x25519.

                                                            {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_dhe_ke});
   acceptEarlyData();
   setUpExpectingClientHello();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.serverCert = cert_;
         res.alpn = "h2";
         res.ticketAgeAdd = 0;
         res.ticketIssueTime =
             std::chrono::system_clock::now() - std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumesecret")));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("client")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bdr")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("helloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ResumptionPskBinder, RangeMatches("")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'd', 'r'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ClientEarlyTraffic, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'e', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::EarlyExporter, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'e', 'm'});
       }));
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, generateSharedSecret(RangeMatches("keyshare")))
             .WillOnce(InvokeWithoutArgs(
                 []() { return IOBuf::copyBuffer("sharedsecret"); }));
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("servershare");
         }));
         return ret;
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto shlo = TestMessages::serverHello();
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = 0;
     shlo.extensions.push_back(encodeExtension(std::move(serverPsk)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(shlo))));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cet"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("earlykey"),
                           IOBuf::copyBuffer("earlyiv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* earlyaead;
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* earlyrrl;
   MockEncryptedReadRecordLayer* handshakerrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"earlykey", &earlyaead},
                       {"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   Sequence readRecSeq;
   expectEncryptedReadRecordLayerCreation(
       &earlyrrl, &earlyaead, StringPiece("cet"), folly::none, &readRecSeq);
   expectEncryptedReadRecordLayerCreation(
       &handshakerrl, &raead, StringPiece("cht"), false, &readRecSeq);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExtEarly(), TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("chlo_shlo_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
 
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingEarlyData);
   EXPECT_EQ(state_.handshakeReadRecordLayer().get(), handshakerrl);
   EXPECT_EQ(state_.readRecordLayer().get(), earlyrrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::EarlyData);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_FALSE(state_.sigScheme().hasValue());
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.pskMode(), PskKeyExchangeMode::psk_dhe_ke);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Accepted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotReplay);
   EXPECT_TRUE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.earlyExporterMasterSecret(), IOBuf::copyBuffer("eem")));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskEarlyFlow
	)

Definition at line 2239 of file ServerProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::AppTraffic, ASSERT_EQ, fizz::server::ResumptionState::cipher, fizz::ClientEarlyTraffic, fizz::ClientHandshakeTraffic, fizz::test::TestMessages::clientHelloPskEarly(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::EarlyData, fizz::EarlyExporter, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::test::TestMessages::encryptedExtEarly(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::key_share, makeRandom(), folly::gen::move, fizz::None, folly::none, fizz::server::NotReplay, now(), fizz::Plaintext, fizz::client::detail::processEvent(), fizz::psk_ke, random(), fizz::test::TestMessages::removeExtension(), fizz::Resumption, fizz::ResumptionPskBinder, fizz::server::ResumptionState::resumptionSecret, fizz::ServerPresharedKey::selected_identity, fizz::ServerAppTraffic, fizz::server::ResumptionState::serverCert, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, and fizz::detail::write().

                                                         {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
   acceptEarlyData();
   setUpExpectingClientHello();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.serverCert = cert_;
         res.alpn = "h2";
         res.ticketAgeAdd = 0;
         res.ticketIssueTime =
             std::chrono::system_clock::now() - std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
   Sequence contextSeq;
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumesecret")));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("client")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bdr")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("helloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ResumptionPskBinder, RangeMatches("")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'd', 'r'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ClientEarlyTraffic, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'e', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::EarlyExporter, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'e', 'm'});
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveHandshakeSecret());
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto shlo = TestMessages::serverHello();
     TestMessages::removeExtension(shlo, ExtensionType::key_share);
     ServerPresharedKey serverPsk;
     serverPsk.selected_identity = 0;
     shlo.extensions.push_back(encodeExtension(std::move(serverPsk)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(shlo))));
     content.data = IOBuf::copyBuffer("writtenshlo");
     return content;
   }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cet"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("earlykey"),
                           IOBuf::copyBuffer("earlyiv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* earlyaead;
   MockAead* raead;
   MockAead* waead;
   MockAead* appwaead;
   MockEncryptedReadRecordLayer* earlyrrl;
   MockEncryptedReadRecordLayer* handshakerrl;
   MockEncryptedWriteRecordLayer* wrl;
   MockEncryptedWriteRecordLayer* appwrl;
   expectAeadCreation({{"earlykey", &earlyaead},
                       {"clientkey", &raead},
                       {"serverkey", &waead},
                       {"serverappkey", &appwaead}});
   Sequence readRecSeq;
   expectEncryptedReadRecordLayerCreation(
       &earlyrrl, &earlyaead, StringPiece("cet"), folly::none, &readRecSeq);
   expectEncryptedReadRecordLayerCreation(
       &handshakerrl, &raead, StringPiece("cht"), false, &readRecSeq);
   Sequence recSeq;
   expectEncryptedWriteRecordLayerCreation(
       &wrl,
       &waead,
       StringPiece("sht"),
       [](TLSMessage& msg, auto writeRecord) {
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment,
             getEncryptedHandshakeWrite(
                 TestMessages::encryptedExtEarly(), TestMessages::finished())));
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = writeRecord->getEncryptionLevel();
         content.data = folly::IOBuf::copyBuffer("handshake");
         return content;
       },
       &recSeq);
   expectEncryptedWriteRecordLayerCreation(
       &appwrl, &appwaead, StringPiece("sat"), nullptr, &recSeq);
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("chlo_shlo_sfin"); }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("chlo_shlo_sfin")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'x', 'p', 'm'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       deriveAppTrafficSecrets(RangeMatches("chlo_shlo_sfin")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverappkey"),
                           IOBuf::copyBuffer("serverappiv")};
       }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
 
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 2);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenshlo")));
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
 
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("handshake")));
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
 
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingEarlyData);
   EXPECT_EQ(state_.handshakeReadRecordLayer().get(), handshakerrl);
   EXPECT_EQ(state_.readRecordLayer().get(), earlyrrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::EarlyData);
   EXPECT_EQ(state_.writeRecordLayer().get(), appwrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.serverCert(), cert_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_FALSE(state_.sigScheme().hasValue());
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.pskMode(), PskKeyExchangeMode::psk_ke);
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::None);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Accepted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotReplay);
   EXPECT_TRUE(state_.clientClockSkew().hasValue());
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.exporterMasterSecret(), IOBuf::copyBuffer("expm")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.earlyExporterMasterSecret(), IOBuf::copyBuffer("eem")));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNullExtensions
	)

Definition at line 2473 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), EXPECT_CALL, and fizz::client::detail::processEvent().

                                                           {
   addExtensions_ = false;
   setUpExpectingClientHello();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_CALL(*extensions_, getExtensions(_)).Times(0);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloLegacySessionId
	)

Definition at line 2483 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::change_cipher_spec, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::Handshake, fizz::handshake, folly::gen::move, fizz::Plaintext, fizz::client::detail::processEvent(), and fizz::detail::write().

                                                            {
   setUpExpectingClientHello();
   auto chloWithLegacy = TestMessages::clientHello();
   chloWithLegacy.legacy_session_id = IOBuf::copyBuffer("middleboxes");
   auto actions =
       getActions(detail::processEvent(state_, std::move(chloWithLegacy)));
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 3);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[1].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[2].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[2].encryptionLevel, EncryptionLevel::Handshake);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloLegacyHrr
	)

Definition at line 2500 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::change_cipher_spec, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), EXPECT_EQ, fizz::handshake, folly::gen::move, fizz::Plaintext, fizz::client::detail::processEvent(), fizz::secp256r1, fizz::detail::write(), and fizz::x25519.

                                                      {
   setUpExpectingClientHello();
   auto chloWithLegacy = TestMessages::clientHello();
   chloWithLegacy.legacy_session_id = IOBuf::copyBuffer("middleboxes");
   context_->setSupportedGroups({NamedGroup::secp256r1, NamedGroup::x25519});
   auto actions =
       getActions(detail::processEvent(state_, std::move(chloWithLegacy)));
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[1].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Plaintext);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingClientHello);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloFullHandshake
	)

Definition at line 2518 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), and fizz::client::detail::processEvent().

                                                          {
   setUpExpectingClientHello();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
   expectActions<MutateState, WriteToSocket>(actions);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPsk
	)

Definition at line 2525 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPsk(), fizz::client::detail::processEvent(), and fizz::psk_ke.

                                                {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
   setUpExpectingClientHello();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskDhe
	)

Definition at line 2533 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPsk(), fizz::client::detail::processEvent(), and fizz::psk_dhe_ke.

                                                   {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_dhe_ke});
   setUpExpectingClientHello();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskModeMismatch
	)

Definition at line 2541 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), folly::gen::move, fizz::client::detail::processEvent(), fizz::psk_key_exchange_modes, and fizz::test::TestMessages::removeExtension().

                                                            {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::psk_key_exchange_modes);
   PskKeyExchangeModes modes;
   chlo.extensions.push_back(encodeExtension(std::move(modes)));
   TestMessages::addPsk(chlo);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoSni
	)

Definition at line 2552 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::test::TestMessages::clientHello(), folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::server_name.

                                                  {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::server_name);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloFullHandshakeRejectedPsk
	)

Definition at line 2560 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPsk(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::none, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                     {
   setUpExpectingClientHello();
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     return std::make_pair(PskType::Rejected, none);
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Rejected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskNoModes
	)

Definition at line 2574 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::test::TestMessages::clientHelloPsk(), fizz::missing_extension, folly::gen::move, fizz::client::detail::processEvent(), fizz::psk_key_exchange_modes, and fizz::test::TestMessages::removeExtension().

                                                       {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHelloPsk();
   TestMessages::removeExtension(chlo, ExtensionType::psk_key_exchange_modes);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::missing_extension, "no psk modes");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskNotSupported
	)

Definition at line 2583 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::test::TestMessages::clientHello(), EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::NotSupported, fizz::client::detail::processEvent(), fizz::psk_key_exchange_modes, and fizz::test::TestMessages::removeExtension().

                                                            {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::psk_key_exchange_modes);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::NotSupported);
   EXPECT_FALSE(state_.pskMode().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloPskBadBinder
	)

Definition at line 2595 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_record_mac, fizz::PskBinder::binder, fizz::ClientPresharedKey::binders, chlo, fizz::test::TestMessages::clientHelloPsk(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::ClientPresharedKey::identities, folly::gen::move, fizz::pre_shared_key, fizz::client::detail::processEvent(), fizz::PskIdentity::psk_identity, and fizz::test::TestMessages::removeExtension().

                                                         {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHelloPsk();
   TestMessages::removeExtension(chlo, ExtensionType::pre_shared_key);
   ClientPresharedKey cpk;
   PskIdentity ident;
   ident.psk_identity = folly::IOBuf::copyBuffer("ident");
   cpk.identities.push_back(std::move(ident));
   PskBinder binder;
   binder.binder = folly::IOBuf::copyBuffer("verifyxxxx");
   cpk.binders.push_back(std::move(binder));
   chlo.extensions.push_back(encodeExtension(std::move(cpk)));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::bad_record_mac, "binder does not match");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloFallback
	)

Definition at line 2612 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::test::Error, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), string, and fizz::supported_versions.

                                                     {
   context_->setVersionFallbackEnabled(true);
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_versions);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectActions<MutateState, AttemptVersionFallback>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Error);
 
   auto fallback = expectAction<AttemptVersionFallback>(actions);
   std::string expected(
       "\x16\x03\x01\x00\x13"
       "clienthelloencoding",
       24);
   EXPECT_EQ(fallback.clientHello->moveToFbString().toStdString(), expected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoSupportedVersions
	)

Definition at line 2631 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), folly::gen::move, fizz::client::detail::processEvent(), fizz::protocol_version, fizz::test::TestMessages::removeExtension(), and fizz::supported_versions.

                                                                {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_versions);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions,
       AlertDescription::protocol_version,
       "supported version mismatch");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloSupportedVersionsMismatch
	)

Definition at line 2643 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), folly::gen::move, fizz::client::detail::processEvent(), fizz::protocol_version, fizz::test::TestMessages::removeExtension(), fizz::supported_versions, and fizz::SupportedVersions::versions.

                                                                      {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_versions);
   SupportedVersions supportedVersions;
   supportedVersions.versions.push_back(static_cast<ProtocolVersion>(0x0200));
   clientHello.extensions.push_back(
       encodeExtension(std::move(supportedVersions)));
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions,
       AlertDescription::protocol_version,
       "supported version mismatch");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCipherMismatch
	)

Definition at line 2659 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::handshake_failure, folly::gen::move, and fizz::client::detail::processEvent().

                                                           {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   clientHello.cipher_suites.clear();
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "no cipher match");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoSupportedGroups
	)

Definition at line 2669 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::missing_extension, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::supported_groups.

                                                              {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_groups);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::missing_extension, "no named groups");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNamedGroupsMismatch
	)

Definition at line 2679 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), fizz::handshake_failure, folly::gen::move, fizz::SupportedGroups::named_group_list, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::supported_groups.

                                                                {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_groups);
   SupportedGroups sg;
   sg.named_group_list.push_back(static_cast<NamedGroup>(0x0707));
   clientHello.extensions.push_back(encodeExtension(std::move(sg)));
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "no group match");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoClientKeyShare
	)

Definition at line 2692 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::key_share, fizz::missing_extension, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                             {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::key_share);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::missing_extension, "no client share");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoSigScemes
	)

Definition at line 2702 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::missing_extension, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::signature_algorithms.

                                                        {
   setUpExpectingClientHello();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(
       clientHello, ExtensionType::signature_algorithms);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::missing_extension, "no sig schemes");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloDataAfter
	)

Definition at line 2713 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), EXPECT_CALL, fizz::client::detail::processEvent(), testing::Return(), and fizz::unexpected_message.

                                                      {
   setUpExpectingClientHello();
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "data after client hello");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoAlpn
	)

Definition at line 2723 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, chlo, fizz::test::TestMessages::clientHello(), EXPECT_FALSE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                   {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_FALSE(state_.alpn().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloAlpnMismatch
	)

Definition at line 2734 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), alpn, fizz::application_layer_protocol_negotiation, chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_FALSE, folly::gen::move, fizz::ProtocolName::name, fizz::client::detail::processEvent(), fizz::ProtocolNameList::protocol_name_list, and fizz::test::TestMessages::removeExtension().

                                                         {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
   ProtocolNameList alpn;
   ProtocolName gopher;
   gopher.name = folly::IOBuf::copyBuffer("gopher");
   alpn.protocol_name_list.push_back(std::move(gopher));
   chlo.extensions.push_back(encodeExtension(std::move(alpn)));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_FALSE(state_.alpn().hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloServerPref
	)

Definition at line 2750 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), alpn, fizz::application_layer_protocol_negotiation, chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_EQ, folly::gen::move, fizz::ProtocolName::name, fizz::client::detail::processEvent(), fizz::ProtocolNameList::protocol_name_list, and fizz::test::TestMessages::removeExtension().

                                                       {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
   ProtocolNameList alpn;
   ProtocolName gopher;
   gopher.name = folly::IOBuf::copyBuffer("gopher");
   alpn.protocol_name_list.push_back(std::move(gopher));
   ProtocolName h2;
   h2.name = folly::IOBuf::copyBuffer("h2");
   alpn.protocol_name_list.push_back(std::move(h2));
   chlo.extensions.push_back(encodeExtension(std::move(alpn)));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(*state_.alpn(), "h2");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloAcceptEarlyData
	)

Definition at line 2769 of file ServerProtocolTest.cpp.

References fizz::Accepted, fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPskEarly(), fizz::EarlyData, EXPECT_EQ, fizz::server::NotReplay, fizz::client::detail::processEvent(), and fizz::Resumption.

                                                            {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingEarlyData);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Accepted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotReplay);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::EarlyData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloEarlyDataNotAttemptedWithAppTokenValidator
	)

Definition at line 2787 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPsk(), EXPECT_EQ, EXPECT_TRUE, testing::InvokeWithoutArgs(), folly::gen::move, fizz::NotAttempted, ON_CALL, fizz::client::detail::processEvent(), and fizz::Resumption.

                                                                {
   acceptEarlyData();
   setUpExpectingClientHello();
   auto validator = std::make_unique<MockAppTokenValidator>();
   auto validatorPtr = validator.get();
   state_.appTokenValidator() = std::move(validator);
 
   ON_CALL(*validatorPtr, validate(_)).WillByDefault(InvokeWithoutArgs([]() {
     EXPECT_TRUE(false)
         << "Early data not attempted, validator shoudn't be called";
     return false;
   }));
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloAcceptEarlyDataWithValidAppToken
	)

Definition at line 2810 of file ServerProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::appToken, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHelloPskEarly(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), testing::InvokeWithoutArgs(), folly::gen::move, fizz::server::NotReplay, now(), fizz::client::detail::processEvent(), fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, string, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::ResumptionState::version.

                                                                             {
   acceptEarlyData();
   setUpExpectingClientHello();
   auto validator = std::make_unique<MockAppTokenValidator>();
   auto validatorPtr = validator.get();
   state_.appTokenValidator() = std::move(validator);
 
   std::string appTokenStr("appToken");
 
   EXPECT_CALL(*validatorPtr, validate(_))
       .WillOnce(Invoke([&appTokenStr](const ResumptionState& resumptionState) {
         EXPECT_TRUE(IOBufEqualTo()(
             resumptionState.appToken, IOBuf::copyBuffer(appTokenStr)));
         return true;
       }));
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0xffffffff;
         res.ticketIssueTime =
             std::chrono::system_clock::now() - std::chrono::seconds(100);
         res.appToken = IOBuf::copyBuffer(appTokenStr);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingEarlyData);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Accepted);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::NotReplay);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyData
	)

Definition at line 2850 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPskEarly(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, fizz::Handshake, testing::InvokeWithoutArgs(), fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                            {
   setUpExpectingClientHello();
 
   auto rrl = new MockEncryptedReadRecordLayer(EncryptionLevel::Handshake);
   EXPECT_CALL(*factory_, makeEncryptedReadRecordLayer(_))
       .WillOnce(InvokeWithoutArgs(
           [rrl]() { return std::unique_ptr<EncryptedReadRecordLayer>(rrl); }));
   EXPECT_CALL(*rrl, setSkipFailedDecryption(true));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloHrrRejectEarlyData
	)

Definition at line 2873 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPskEarly(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, testing::Invoke(), fizz::Plaintext, fizz::client::detail::processEvent(), fizz::Rejected, fizz::secp256r1, and fizz::x25519.

                                                               {
   acceptEarlyData();
   context_->setSupportedGroups({NamedGroup::secp256r1, NamedGroup::x25519});
   setUpExpectingClientHello();
 
   auto rrl = new MockPlaintextReadRecordLayer();
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke(
           [rrl]() { return std::unique_ptr<PlaintextReadRecordLayer>(rrl); }));
   EXPECT_CALL(*rrl, setSkipEncryptedRecords(true));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingClientHello);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_FALSE(state_.earlyExporterMasterSecret().hasValue());
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieRejectEarlyData
	)

Definition at line 2900 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), fizz::AppTraffic, c, chlo, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_EQ, fizz::Handshake, folly::gen::move, fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                                  {
   acceptEarlyData();
   expectCookie();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
   TestMessages::addPsk(chlo);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataPskRejected
	)

Definition at line 2926 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, fizz::test::TestMessages::clientHelloPskEarly(), EXPECT_CALL, EXPECT_EQ, fizz::Handshake, testing::InvokeWithoutArgs(), folly::none, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                       {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     return std::make_pair(PskType::Rejected, none);
   }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Rejected);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataReplayCache
	)

Definition at line 2949 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), check(), fizz::test::TestMessages::clientHelloPskEarly(), fizz::server::DefinitelyReplay, EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::makeFuture(), fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                                       {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   EXPECT_CALL(*replayCache_, check(_)).WillOnce(InvokeWithoutArgs([] {
     return folly::makeFuture(ReplayCacheResult::DefinitelyReplay);
   }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_EQ(state_.replayCacheResult(), ReplayCacheResult::DefinitelyReplay);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataNoAlpn
	)

Definition at line 2967 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, chlo, fizz::test::TestMessages::clientHelloPskEarly(), EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), fizz::Rejected, fizz::test::TestMessages::removeExtension(), and fizz::Resumption.

                                                                  {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHelloPskEarly();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataDiffAlpn
	)

Definition at line 2983 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), alpn, fizz::application_layer_protocol_negotiation, chlo, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_EQ, folly::gen::move, fizz::ProtocolName::name, fizz::client::detail::processEvent(), fizz::ProtocolNameList::protocol_name_list, fizz::Rejected, fizz::test::TestMessages::removeExtension(), and fizz::Resumption.

                                                                    {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
   ProtocolNameList alpn;
   ProtocolName h2;
   h2.name = folly::IOBuf::copyBuffer("h3");
   alpn.protocol_name_list.push_back(std::move(h2));
   chlo.extensions.push_back(encodeExtension(std::move(alpn)));
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   TestMessages::addPsk(chlo);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataAfterHrr
	)

Definition at line 3006 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHelloPskEarly(), EXPECT_EQ, fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                                    {
   acceptEarlyData();
   setUpExpectingClientHelloRetry();
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataClockBehind
	)

Definition at line 3019 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), EXPECT_EQ, EXPECT_LT, folly::gen::move, fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                                       {
   context_->setEarlyDataSettings(
       true,
       {std::chrono::milliseconds(-10), std::chrono::milliseconds(10)},
       replayCache_);
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   TestMessages::addPsk(chlo, 1000);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_LT(*state_.clientClockSkew(), std::chrono::milliseconds(-5000));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataClockAhead
	)

Definition at line 3039 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), EXPECT_EQ, EXPECT_GT, folly::gen::move, fizz::client::detail::processEvent(), fizz::Rejected, and fizz::Resumption.

                                                                      {
   context_->setEarlyDataSettings(
       true,
       {std::chrono::milliseconds(-10), std::chrono::milliseconds(10)},
       replayCache_);
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   TestMessages::addPsk(chlo, 200000);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_GT(*state_.clientClockSkew(), std::chrono::milliseconds(5000));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataTicketAgeOverflow
	)

Definition at line 3059 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), fizz::server::ResumptionState::alpn, chlo, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, EXPECT_GT, testing::InvokeWithoutArgs(), folly::gen::move, now(), fizz::client::detail::processEvent(), fizz::Rejected, fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::ResumptionState::version.

                                                                             {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0xffffffff;
         res.ticketIssueTime =
             std::chrono::system_clock::now() - std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   TestMessages::addPsk(chlo, 2000000);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_GT(*state_.clientClockSkew(), std::chrono::milliseconds(5000));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataNegativeExpectedAge
	)

Definition at line 3089 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::addPsk(), fizz::server::ResumptionState::alpn, chlo, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, EXPECT_GT, testing::InvokeWithoutArgs(), folly::gen::move, now(), fizz::client::detail::processEvent(), fizz::Rejected, fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::ResumptionState::version.

                                                                               {
   acceptEarlyData();
   setUpExpectingClientHello();
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0;
         res.ticketIssueTime =
             std::chrono::system_clock::now() + std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(ClientEarlyData()));
   TestMessages::addPsk(chlo, 2000000);
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_GT(*state_.clientClockSkew(), std::chrono::milliseconds(5000));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRejectEarlyDataInvalidAppToken
	)

Definition at line 3119 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::appToken, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHelloPskEarly(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), testing::InvokeWithoutArgs(), folly::gen::move, now(), fizz::client::detail::processEvent(), fizz::Rejected, fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, string, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::ResumptionState::version.

                                                                           {
   acceptEarlyData();
   setUpExpectingClientHello();
   auto validator = std::make_unique<MockAppTokenValidator>();
   auto validatorPtr = validator.get();
   state_.appTokenValidator() = std::move(validator);
 
   std::string appTokenStr("appToken");
 
   EXPECT_CALL(*validatorPtr, validate(_))
       .WillOnce(Invoke([&appTokenStr](const ResumptionState& resumptionState) {
         EXPECT_TRUE(IOBufEqualTo()(
             resumptionState.appToken, IOBuf::copyBuffer(appTokenStr)));
         return false;
       }));
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0xffffffff;
         res.ticketIssueTime =
             std::chrono::system_clock::now() - std::chrono::seconds(100);
         res.appToken = IOBuf::copyBuffer(appTokenStr);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::clientHelloPskEarly()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloHandshakeLogging
	)

Definition at line 3158 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, fizz::test::TestMessages::clientHello(), fizz::ecdsa_secp256r1_sha256, EXPECT_EQ, EXPECT_TRUE, fizz::key_share, fizz::client::detail::processEvent(), fizz::psk_key_exchange_modes, fizz::rsa_pss_sha256, fizz::server_name, fizz::signature_algorithms, fizz::supported_groups, fizz::supported_versions, fizz::test::TestProtocolVersion, fizz::tls_1_2, fizz::TLS_AES_128_GCM_SHA256, and fizz::TLS_AES_256_GCM_SHA384.

                                                             {
   setUpExpectingClientHello();
   state_.handshakeLogging() = std::make_unique<HandshakeLogging>();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHello()));
   processStateMutations(actions);
   EXPECT_EQ(
       state_.handshakeLogging()->clientLegacyVersion, ProtocolVersion::tls_1_2);
   EXPECT_EQ(
       state_.handshakeLogging()->clientSupportedVersions,
       std::vector<ProtocolVersion>({TestProtocolVersion}));
   EXPECT_EQ(
       state_.handshakeLogging()->clientCiphers,
       std::vector<CipherSuite>({CipherSuite::TLS_AES_128_GCM_SHA256,
                                 CipherSuite::TLS_AES_256_GCM_SHA384}));
   EXPECT_EQ(
       state_.handshakeLogging()->clientExtensions,
       std::vector<ExtensionType>(
           {ExtensionType::supported_versions,
            ExtensionType::supported_groups,
            ExtensionType::key_share,
            ExtensionType::signature_algorithms,
            ExtensionType::server_name,
            ExtensionType::application_layer_protocol_negotiation,
            ExtensionType::psk_key_exchange_modes}));
   EXPECT_EQ(
       state_.handshakeLogging()->clientSignatureAlgorithms,
       std::vector<SignatureScheme>({SignatureScheme::ecdsa_secp256r1_sha256,
                                     SignatureScheme::rsa_pss_sha256}));
   EXPECT_EQ(*state_.handshakeLogging()->clientSessionIdSent, false);
   EXPECT_TRUE(state_.handshakeLogging()->clientRandom.hasValue());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloHandshakeLoggingError
	)

Definition at line 3191 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, EXPECT_EQ, folly::gen::move, and fizz::client::detail::processEvent().

                                                                  {
   setUpExpectingClientHello();
   state_.handshakeLogging() = std::make_unique<HandshakeLogging>();
   ClientHello chlo;
   chlo.legacy_version = static_cast<ProtocolVersion>(0x0301);
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   EXPECT_EQ(
       state_.handshakeLogging()->clientLegacyVersion,
       static_cast<ProtocolVersion>(0x0301));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloNoCompressionMethods
	)

Definition at line 3202 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::test::TestMessages::clientHello(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                                 {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   chlo.legacy_compression_methods.clear();
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "compression methods");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloDuplicateExtensions
	)

Definition at line 3211 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                                {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   chlo.extensions.push_back(encodeExtension(SupportedGroups()));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "duplicate extension");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloDuplicateGroups
	)

Definition at line 3220 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, fizz::ClientKeyShare::client_shares, fizz::test::TestMessages::clientHello(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::KeyShareEntry::group, fizz::illegal_parameter, fizz::KeyShareEntry::key_exchange, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::x25519.

                                                            {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   TestMessages::removeExtension(chlo, ExtensionType::key_share);
 
   ClientKeyShare keyShare;
   KeyShareEntry entry1, entry2;
 
   entry1.group = NamedGroup::x25519;
   entry1.key_exchange = folly::IOBuf::copyBuffer("keyshare");
   keyShare.client_shares.push_back(std::move(entry1));
 
   entry2.group = NamedGroup::x25519;
   entry2.key_exchange = folly::IOBuf::copyBuffer("keyshare");
   keyShare.client_shares.push_back(std::move(entry2));
 
   chlo.extensions.push_back(encodeExtension(std::move(keyShare)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "duplicate client key share");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestRetryClientHelloStillNoKeyShare
	)

Definition at line 3245 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), fizz::illegal_parameter, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                                 {
   setUpExpectingClientHelloRetry();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::key_share);
   ClientKeyShare keyShare;
   clientHello.extensions.push_back(encodeExtension(std::move(keyShare)));
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "key share not found");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestRetryClientHelloCookie
	)

Definition at line 3257 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), c, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                        {
   setUpExpectingClientHelloRetry();
   expectCookie();
   auto clientHello = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   clientHello.extensions.push_back(encodeExtension(std::move(c)));
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "cookie after statefull hrr");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestRetryClientHelloDifferentVersion
	)

Definition at line 3272 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::clientHello(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::supported_versions.

                                                                  {
   context_->setVersionFallbackEnabled(true);
   setUpExpectingClientHelloRetry();
   auto clientHello = TestMessages::clientHello();
   TestMessages::removeExtension(clientHello, ExtensionType::supported_versions);
   auto actions =
       getActions(detail::processEvent(state_, std::move(clientHello)));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "version mismatch with previous negotiation");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRenegotiatePskCipher
	)

Definition at line 3285 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHelloPsk(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, now(), fizz::client::detail::processEvent(), fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, fizz::TLS_CHACHA20_POLY1305_SHA256, and fizz::server::ResumptionState::version.

                                                                 {
   setUpExpectingClientHello();
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_CHACHA20_POLY1305_SHA256;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0;
         res.ticketIssueTime =
             std::chrono::system_clock::now() + std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloRenegotiatePskCipherIncompatible
	)

Definition at line 3310 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::cipher, fizz::test::TestMessages::clientHelloPsk(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, now(), fizz::client::detail::processEvent(), fizz::Rejected, fizz::Resumption, fizz::server::ResumptionState::resumptionSecret, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::server::ResumptionState::ticketIssueTime, fizz::TLS_AES_128_GCM_SHA256, fizz::TLS_AES_256_GCM_SHA384, and fizz::server::ResumptionState::version.

                                                                             {
   setUpExpectingClientHello();
 
   EXPECT_CALL(*mockTicketCipher_, _decrypt(_))
       .WillOnce(InvokeWithoutArgs([=]() {
         ResumptionState res;
         res.version = TestProtocolVersion;
         res.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
         res.resumptionSecret = folly::IOBuf::copyBuffer("resumesecret");
         res.alpn = "h2";
         res.ticketAgeAdd = 0;
         res.ticketIssueTime =
             std::chrono::system_clock::now() + std::chrono::seconds(100);
         return std::make_pair(PskType::Resumption, std::move(res));
       }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::clientHelloPsk()));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.pskType(), PskType::Rejected);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookie
	)

Definition at line 3335 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), c, chlo, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and fizz::TLS_AES_128_GCM_SHA256.

                                                   {
   expectCookie();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieFail
	)

Definition at line 3351 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), c, chlo, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::decrypt_error, fizz::encodeExtension(), folly::gen::move, and fizz::client::detail::processEvent().

                                                       {
   expectCookie();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("xyz");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::decrypt_error, "decrypt cookie");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieNoCipher
	)

Definition at line 3365 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), c, chlo, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), folly::gen::move, fizz::client::detail::processEvent(), and fizz::unsupported_extension.

                                                           {
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::unsupported_extension, "no cookie cipher");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieVersionMismatch
	)

Definition at line 3378 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::CookieState::appToken, c, chlo, fizz::server::CookieState::chloHash, fizz::server::CookieState::cipher, fizz::test::TestMessages::clientHello(), cookie, fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::protocol_version, fizz::tls_1_2, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::CookieState::version.

                                                                  {
   setUpExpectingClientHello();
   acceptCookies();
 
   EXPECT_CALL(*mockCookieCipher_, _decrypt(_)).WillOnce(Invoke([](Buf& cookie) {
     EXPECT_TRUE(IOBufEqualTo()(cookie, IOBuf::copyBuffer("cookie")));
     CookieState cs;
     cs.version = ProtocolVersion::tls_1_2;
     cs.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
     cs.chloHash = IOBuf::copyBuffer("chlohash");
     cs.appToken = IOBuf::create(0);
     return folly::Optional<CookieState>(std::move(cs));
   }));
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions,
       AlertDescription::protocol_version,
       "version mismatch with cookie");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieCipherMismatch
	)

Definition at line 3404 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::CookieState::appToken, c, chlo, fizz::server::CookieState::chloHash, fizz::server::CookieState::cipher, fizz::test::TestMessages::clientHello(), cookie, fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_TRUE, fizz::handshake_failure, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestProtocolVersion, fizz::TLS_AES_256_GCM_SHA384, and fizz::server::CookieState::version.

                                                                 {
   setUpExpectingClientHello();
   acceptCookies();
 
   EXPECT_CALL(*mockCookieCipher_, _decrypt(_)).WillOnce(Invoke([](Buf& cookie) {
     EXPECT_TRUE(IOBufEqualTo()(cookie, IOBuf::copyBuffer("cookie")));
     CookieState cs;
     cs.version = TestProtocolVersion;
     cs.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
     cs.chloHash = IOBuf::copyBuffer("chlohash");
     cs.appToken = IOBuf::create(0);
     return folly::Optional<CookieState>(std::move(cs));
   }));
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions,
       AlertDescription::handshake_failure,
       "cipher mismatch with cookie");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieGroupMismatch
	)

Definition at line 3430 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::CookieState::appToken, c, chlo, fizz::server::CookieState::chloHash, fizz::server::CookieState::cipher, fizz::test::TestMessages::clientHello(), cookie, fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_TRUE, fizz::server::CookieState::group, fizz::illegal_parameter, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::secp256r1, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::server::CookieState::version.

                                                                {
   setUpExpectingClientHello();
   acceptCookies();
 
   EXPECT_CALL(*mockCookieCipher_, _decrypt(_)).WillOnce(Invoke([](Buf& cookie) {
     EXPECT_TRUE(IOBufEqualTo()(cookie, IOBuf::copyBuffer("cookie")));
     CookieState cs;
     cs.version = TestProtocolVersion;
     cs.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
     cs.group = NamedGroup::secp256r1;
     cs.chloHash = IOBuf::copyBuffer("chlohash");
     cs.appToken = IOBuf::create(0);
     return folly::Optional<CookieState>(std::move(cs));
   }));
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "group mismatch with cookie");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestClientHelloCookieNoGroup
	)

Definition at line 3457 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), c, chlo, fizz::test::TestMessages::clientHello(), fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::illegal_parameter, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                          {
   expectCookie();
   setUpExpectingClientHello();
 
   auto chlo = TestMessages::clientHello();
   Cookie c;
   c.cookie = IOBuf::copyBuffer("cookie");
   chlo.extensions.push_back(encodeExtension(std::move(c)));
   TestMessages::removeExtension(chlo, ExtensionType::key_share);
   ClientKeyShare keyShare;
   chlo.extensions.push_back(encodeExtension(std::move(keyShare)));
 
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "key share not found");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestNoCertCompressionAlgorithmMatch
	)

Definition at line 3474 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateCompressionAlgorithms::algorithms, chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), EXPECT_EQ, folly::gen::move, folly::none, fizz::client::detail::processEvent(), and fizz::zlib.

                                                                 {
   setUpExpectingClientHello();
   context_->setSupportedCompressionAlgorithms(
       {CertificateCompressionAlgorithm::zlib});
   auto chlo = TestMessages::clientHello();
   CertificateCompressionAlgorithms algos;
   algos.algorithms = {static_cast<CertificateCompressionAlgorithm>(0xfb)};
   chlo.extensions.push_back(encodeExtension(algos));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.serverCertCompAlgo(), folly::none);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertCompressionRequestedNotSupported
	)

Definition at line 3489 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateCompressionAlgorithms::algorithms, chlo, fizz::test::TestMessages::clientHello(), fizz::encodeExtension(), EXPECT_EQ, folly::gen::move, folly::none, and fizz::client::detail::processEvent().

                                                                      {
   setUpExpectingClientHello();
   auto chlo = TestMessages::clientHello();
   CertificateCompressionAlgorithms algos;
   algos.algorithms = {static_cast<CertificateCompressionAlgorithm>(0xfb)};
   chlo.extensions.push_back(encodeExtension(algos));
   auto actions = getActions(detail::processEvent(state_, std::move(chlo)));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.serverCertCompAlgo(), folly::none);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestEarlyAppData
	)

Definition at line 3502 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::appData(), folly::gen::move, and fizz::client::detail::processEvent().

                                              {
   setUpAcceptingEarlyData();
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::appData()));
 
   expectSingleAction<DeliverAppData>(std::move(actions));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestEarlyAppWrite
	)

Definition at line 3511 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::test::TestMessages::appWrite(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                               {
   setUpAcceptingEarlyData();
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::application_data);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
     content.data = IOBuf::copyBuffer("writtenappdata");
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::appWrite()));
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestEndOfEarlyData
	)

Definition at line 3531 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::endOfEarlyData(), EXPECT_CALL, EXPECT_EQ, fizz::Handshake, and fizz::client::detail::processEvent().

                                                {
   setUpAcceptingEarlyData();
   auto handshakeReadRecordLayer = state_.handshakeReadRecordLayer().get();
 
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("eoedencoding")));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::endOfEarlyData()));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.readRecordLayer().get(), handshakeReadRecordLayer);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestEndOfEarlyDataExtraData
	)

Definition at line 3550 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::endOfEarlyData(), EXPECT_CALL, fizz::client::detail::processEvent(), testing::Return(), and fizz::unexpected_message.

                                                         {
   setUpAcceptingEarlyData();
 
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::endOfEarlyData()));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "data after eoed");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFullHandshakeFinished
	)

Definition at line 3562 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::AppTraffic, ASSERT_THAT, fizz::server::ResumptionState::cipher, fizz::ClientAppTraffic, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, testing::ElementsAre(), fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::test::TestMessages::newSessionTicket(), fizz::client::detail::processEvent(), fizz::ResumptionMaster, fizz::server::ResumptionState::resumptionSecret, testing::Return(), fizz::server::ResumptionState::serverCert, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, and fizz::server::ResumptionState::version.

                                                       {
   setUpExpectingFinished();
   Sequence contextSeq;
   EXPECT_CALL(
       *mockHandshakeContext_, getFinishedData(RangeMatches("clihandsec")))
       .InSequence(contextSeq)
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("sfincontext"); }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("finishedencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("clifincontext"); }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ResumptionMaster, RangeMatches("clifincontext")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'r', 's', 'e', 'c'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ClientAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getResumptionSecret(RangeMatches("rsec"), RangeMatches("")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("derivedrsec"); }));
 
   MockAead* raead;
   MockEncryptedReadRecordLayer* rrl;
   expectAeadCreation(&raead, nullptr);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("cat"));
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_))
       .WillOnce(Invoke([=](ResumptionState& resState) {
         EXPECT_EQ(resState.version, TestProtocolVersion);
         EXPECT_EQ(resState.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
         EXPECT_TRUE(IOBufEqualTo()(
             resState.resumptionSecret, IOBuf::copyBuffer("derivedrsec")));
         EXPECT_EQ(resState.serverCert, cert_);
         EXPECT_EQ(*resState.alpn, "h2");
         EXPECT_EQ(resState.ticketAgeAdd, 0x44444444);
         return std::make_pair(
             IOBuf::copyBuffer("ticket"), std::chrono::seconds(100));
       }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::newSessionTicket())));
     content.data = folly::IOBuf::copyBuffer("handshake");
     return content;
   }));
   EXPECT_CALL(*mockKeyScheduler_, clearMasterSecret());
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
 
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   ASSERT_THAT(state_.resumptionMasterSecret(), ElementsAre('r', 's', 'e', 'c'));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedNoTicket
	)

Definition at line 3647 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), EXPECT_CALL, EXPECT_EQ, fizz::test::TestMessages::finished(), testing::InvokeWithoutArgs(), folly::none, and fizz::client::detail::processEvent().

                                                  {
   setUpExpectingFinished();
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     return none;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
   expectActions<MutateState, ReportHandshakeSuccess>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedTicketEarly
	)

Definition at line 3660 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::handshake, testing::Invoke(), fizz::TicketEarlyData::max_early_data_size, folly::gen::move, fizz::test::TestMessages::newSessionTicket(), nst, fizz::client::detail::processEvent(), testing::Return(), and fizz::TLSMessage::type.

                                                     {
   acceptEarlyData();
   setUpExpectingFinished();
 
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto nst = TestMessages::newSessionTicket();
     TicketEarlyData early;
     early.max_early_data_size = 0xffffffff;
     nst.extensions.push_back(encodeExtension(std::move(early)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(nst))));
     content.data = folly::IOBuf::copyBuffer("handshake");
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedPskNotSupported
	)

Definition at line 3686 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::finished(), fizz::NotSupported, and fizz::client::detail::processEvent().

                                                         {
   setUpExpectingFinished();
   state_.pskType() = PskType::NotSupported;
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
   expectActions<MutateState, ReportHandshakeSuccess>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedNoAutomaticNewSessionTicket
	)

Definition at line 3697 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, EXPECT_EQ, fizz::test::TestMessages::finished(), and fizz::client::detail::processEvent().

                                                                     {
   setUpExpectingFinished();
   context_->setSendNewSessionTicket(false);
 
   EXPECT_CALL(*mockKeyScheduler_, clearMasterSecret());
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
   expectActions<MutateState, ReportHandshakeSuccess>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedMismatch
	)

Definition at line 3709 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, fizz::test::TestMessages::finished(), fizz::detail::getFinishedData(), testing::InvokeWithoutArgs(), folly::none, and fizz::client::detail::processEvent().

                                                  {
   setUpExpectingFinished();
   EXPECT_CALL(
       *mockHandshakeContext_, getFinishedData(RangeMatches("clihandsec")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("wrongverifydata"); }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
 
   expectError<FizzException>(actions, none, "finished verify failure");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestFinishedExtraData
	)

Definition at line 3722 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, fizz::test::TestMessages::finished(), folly::none, fizz::client::detail::processEvent(), and testing::Return().

                                                   {
   setUpExpectingFinished();
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
 
   expectError<FizzException>(actions, none, "data after finished");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestExpectingFinishedAppWrite
	)

Definition at line 3733 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::test::TestMessages::appWrite(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                                           {
   setUpExpectingFinished();
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::application_data);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
     content.data = IOBuf::copyBuffer("writtenappdata");
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::appWrite()));
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicket
	)

Definition at line 3753 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::AppTraffic, fizz::server::ResumptionState::cipher, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), folly::gen::move, fizz::test::TestMessages::newSessionTicket(), fizz::client::detail::processEvent(), fizz::server::ResumptionState::resumptionSecret, testing::Return(), fizz::server::ResumptionState::serverCert, fizz::test::TestProtocolVersion, fizz::server::ResumptionState::ticketAgeAdd, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, fizz::server::ResumptionState::version, and fizz::detail::write().

                                                       {
   setUpAcceptingData();
   context_->setSendNewSessionTicket(false);
   state_.resumptionMasterSecret() = std::vector<uint8_t>({'r', 's', 'e', 'c'});
 
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("clifincontext"); }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getResumptionSecret(RangeMatches("rsec"), RangeMatches("")))
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("derivedrsec"); }));
 
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_))
       .WillOnce(Invoke([=](ResumptionState& resState) {
         EXPECT_EQ(resState.version, TestProtocolVersion);
         EXPECT_EQ(resState.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
         EXPECT_TRUE(IOBufEqualTo()(
             resState.resumptionSecret, IOBuf::copyBuffer("derivedrsec")));
         EXPECT_EQ(resState.serverCert, cert_);
         EXPECT_EQ(*resState.alpn, "h2");
         EXPECT_EQ(resState.ticketAgeAdd, 0x44444444);
         return std::make_pair(
             IOBuf::copyBuffer("ticket"), std::chrono::seconds(100));
       }));
   auto nstBuf = folly::IOBuf::copyBuffer("nst");
   EXPECT_CALL(*appWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = appWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::newSessionTicket())));
     content.data = nstBuf->clone();
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, WriteNewSessionTicket()));
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::AppTraffic);
   EXPECT_TRUE(IOBufEqualTo()(nstBuf, write.contents[0].data));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicketWithTicketEarly
	)

Definition at line 3800 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, fizz::handshake, testing::Invoke(), fizz::TicketEarlyData::max_early_data_size, folly::gen::move, fizz::test::TestMessages::newSessionTicket(), nst, fizz::client::detail::processEvent(), and fizz::TLSMessage::type.

                                                                      {
   acceptEarlyData();
   setUpAcceptingData();
   context_->setSendNewSessionTicket(false);
 
   EXPECT_CALL(*appWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = appWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     auto nst = TestMessages::newSessionTicket();
     TicketEarlyData early;
     early.max_early_data_size = 0xffffffff;
     nst.extensions.push_back(encodeExtension(std::move(early)));
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodeHandshake(std::move(nst))));
     content.data = folly::IOBuf::copyBuffer("handshake");
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, WriteNewSessionTicket()));
   expectSingleAction<WriteToSocket>(std::move(actions));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicketWithAppToken
	)

Definition at line 3824 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::appToken, fizz::WriteNewSessionTicket::appToken, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), testing::Return(), fizz::server::ResumptionState::serverCert, string, fizz::server::ResumptionState::ticketAgeAdd, and fizz::test::writeNewSessionTicket().

                                                                   {
   setUpAcceptingData();
   context_->setSendNewSessionTicket(false);
 
   std::string appToken("appToken");
 
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_))
       .WillOnce(Invoke([=](ResumptionState& resState) {
         EXPECT_EQ(resState.serverCert, cert_);
         EXPECT_EQ(*resState.alpn, "h2");
         EXPECT_EQ(resState.ticketAgeAdd, 0x44444444);
         EXPECT_TRUE(
             IOBufEqualTo()(resState.appToken, IOBuf::copyBuffer(appToken)));
         return std::make_pair(
             IOBuf::copyBuffer("ticket"), std::chrono::seconds(100));
       }));
 
   WriteNewSessionTicket writeNewSessionTicket;
   writeNewSessionTicket.appToken = IOBuf::copyBuffer(appToken);
   auto actions = getActions(
       detail::processEvent(state_, std::move(writeNewSessionTicket)));
   expectSingleAction<WriteToSocket>(std::move(actions));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicketWithAppTokenAfterAutomaticSend
	)

Definition at line 3849 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::server::ResumptionState::alpn, fizz::server::ResumptionState::appToken, fizz::WriteNewSessionTicket::appToken, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::test::TestMessages::finished(), testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), testing::Return(), fizz::server::ResumptionState::serverCert, string, fizz::server::ResumptionState::ticketAgeAdd, and fizz::test::writeNewSessionTicket().

                                                              {
   setUpExpectingFinished();
   context_->setSendNewSessionTicket(true);
 
   // ExpectingFinished -> AcceptingData
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_))
       .WillOnce(Invoke([=](ResumptionState& resState) {
         EXPECT_EQ(resState.serverCert, cert_);
         EXPECT_EQ(*resState.alpn, "h2");
         EXPECT_EQ(resState.ticketAgeAdd, 0x44444444);
         EXPECT_FALSE(resState.appToken);
         return std::make_pair(
             IOBuf::copyBuffer("ticket"), std::chrono::seconds(100));
       }));
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::finished()));
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 
   // AcceptingData: WriteNewSessionTicket
   std::string appToken("appToken");
   EXPECT_CALL(*factory_, makeTicketAgeAdd()).WillOnce(Return(0x44444444));
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_))
       .WillOnce(Invoke([=](ResumptionState& resState) {
         EXPECT_EQ(resState.serverCert, cert_);
         EXPECT_EQ(*resState.alpn, "h2");
         EXPECT_EQ(resState.ticketAgeAdd, 0x44444444);
         EXPECT_TRUE(
             IOBufEqualTo()(resState.appToken, IOBuf::copyBuffer(appToken)));
         return std::make_pair(
             IOBuf::copyBuffer("ticket"), std::chrono::seconds(100));
       }));
   WriteNewSessionTicket writeNewSessionTicket;
   writeNewSessionTicket.appToken = IOBuf::copyBuffer(appToken);
   auto writeNewSessionTicketActions = getActions(
       detail::processEvent(state_, std::move(writeNewSessionTicket)));
   expectSingleAction<WriteToSocket>(std::move(writeNewSessionTicketActions));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicketNoTicket
	)

Definition at line 3892 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), EXPECT_CALL, EXPECT_TRUE, testing::InvokeWithoutArgs(), folly::none, and fizz::client::detail::processEvent().

                                                               {
   setUpAcceptingData();
   context_->setSendNewSessionTicket(false);
 
   EXPECT_CALL(*mockTicketCipher_, _encrypt(_)).WillOnce(InvokeWithoutArgs([]() {
     return none;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, WriteNewSessionTicket()));
   EXPECT_TRUE(actions.empty());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestWriteNewSessionTicketPskNotSupported
	)

Definition at line 3905 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_TRUE, fizz::NotSupported, and fizz::client::detail::processEvent().

                                                                      {
   setUpAcceptingData();
   context_->setSendNewSessionTicket(false);
   state_.pskType() = PskType::NotSupported;
 
   auto actions =
       getActions(detail::processEvent(state_, WriteNewSessionTicket()));
   EXPECT_TRUE(actions.empty());
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAppData
	)

Definition at line 3915 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::appData(), folly::gen::move, and fizz::client::detail::processEvent().

                                         {
   setUpAcceptingData();
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::appData()));
 
   expectSingleAction<DeliverAppData>(std::move(actions));
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestAppWrite
	)

Definition at line 3924 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::AppTraffic, fizz::test::TestMessages::appWrite(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                          {
   setUpAcceptingData();
   EXPECT_CALL(*appWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = appWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::application_data);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
     content.data = IOBuf::copyBuffer("writtenappdata");
     return content;
   }));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::appWrite()));
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::AppTraffic);
   EXPECT_EQ(write.contents[0].contentType, ContentType::application_data);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestKeyUpdateNotRequested
	)

Definition at line 3946 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::keyUpdate(), and fizz::client::detail::processEvent().

                                                       {
   setUpAcceptingData();
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::keyUpdate(false)));
   expectActions<MutateState>(actions);
   EXPECT_EQ(getNumActions<WriteToSocket>(actions, false), 0);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestKeyUpdateExtraData
	)

Definition at line 3954 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, fizz::test::TestMessages::keyUpdate(), folly::none, fizz::client::detail::processEvent(), and testing::Return().

                                                    {
   setUpAcceptingData();
   EXPECT_CALL(*appRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::keyUpdate(false)));
 
   expectError<FizzException>(actions, none, "data after key_update");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestKeyUpdateRequest
	)

Definition at line 3964 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientAppTraffic, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::test::TestMessages::keyUpdate(), fizz::client::detail::processEvent(), testing::Return(), fizz::ServerAppTraffic, fizz::TLSMessage::type, and fizz::detail::write().

                                                  {
   setUpAcceptingData();
   EXPECT_CALL(*mockKeyScheduler_, clientKeyUpdate());
   EXPECT_CALL(*appRead_, hasUnparsedHandshakeData()).WillOnce(Return(false));
 
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ClientAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'a', 't'});
       }));
 
   EXPECT_CALL(*appWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = appWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::keyUpdate(false))));
     content.data = folly::IOBuf::copyBuffer("keyupdated");
     return content;
   }));
 
   EXPECT_CALL(*mockKeyScheduler_, serverKeyUpdate());
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
 
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
 
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
 
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
 
   expectAeadCreation(&raead, &waead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("cat"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("sat"));
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::keyUpdate(true)));
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("keyupdated")));
   processStateMutations(actions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(state_.state(), StateEnum::AcceptingData);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificate
	)

Definition at line 4025 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and testing::Return().

                                             {
   setUpExpectingCertificate();
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("certencoding")));
   clientLeafCert_ = std::make_shared<MockPeerCert>();
   clientIntCert_ = std::make_shared<MockPeerCert>();
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert1")))
       .WillOnce(Return(clientLeafCert_));
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert2")))
       .WillOnce(Return(clientIntCert_));
 
   auto certificate = TestMessages::certificate();
   CertificateEntry entry1;
   entry1.cert_data = folly::IOBuf::copyBuffer("cert1");
   certificate.certificate_list.push_back(std::move(entry1));
   CertificateEntry entry2;
   entry2.cert_data = folly::IOBuf::copyBuffer("cert2");
   certificate.certificate_list.push_back(std::move(entry2));
   auto actions =
       getActions(detail::processEvent(state_, std::move(certificate)));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain()->size(), 2);
   EXPECT_EQ(state_.unverifiedCertChain()->at(0), clientLeafCert_);
   EXPECT_EQ(state_.unverifiedCertChain()->at(1), clientIntCert_);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificateVerify);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateNonemptyContext
	)

Definition at line 4054 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                            {
   setUpExpectingCertificate();
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("certencoding")));
 
   auto badCertMsg = TestMessages::certificate();
   badCertMsg.certificate_request_context =
       folly::IOBuf::copyBuffer("garbagecontext");
   auto actions =
       getActions(detail::processEvent(state_, std::move(badCertMsg)));
 
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "certificate request context must be empty");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateEmptyForbidden
	)

Definition at line 4071 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificate(), fizz::certificate_required, EXPECT_CALL, and fizz::client::detail::processEvent().

                                                           {
   setUpExpectingCertificate();
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("certencoding")));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::certificate()));
 
   expectError<FizzException>(
       actions,
       AlertDescription::certificate_required,
       "certificate requested but none received");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateEmptyPermitted
	)

Definition at line 4085 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificate(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, and fizz::client::detail::processEvent().

                                                           {
   setUpExpectingCertificate();
   context_->setClientAuthMode(ClientAuthMode::Optional);
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("certencoding")));
 
   auto actions =
       getActions(detail::processEvent(state_, TestMessages::certificate()));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_FALSE(state_.unverifiedCertChain().hasValue());
   EXPECT_EQ(state_.clientCert(), nullptr);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifyNoVerifier
	)

Definition at line 4101 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::none, fizz::client::detail::processEvent(), and verify().

                                                             {
   setUpExpectingCertificateVerify();
   context_->setClientCertVerifier(nullptr);
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq);
 
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("certverifyencoding")))
       .InSequence(contextSeq);
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain(), folly::none);
   EXPECT_EQ(state_.clientCert(), clientLeafCert_);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifyWithVerifier
	)

Definition at line 4134 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::none, fizz::client::detail::processEvent(), and verify().

                                                               {
   setUpExpectingCertificateVerify();
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq);
 
   EXPECT_CALL(*certVerifier_, verify(_))
       .InSequence(contextSeq)
       .WillOnce(Invoke(
           [this](const std::vector<std::shared_ptr<const PeerCert>>& certs) {
             EXPECT_EQ(certs.size(), 2);
             EXPECT_EQ(certs[0], clientLeafCert_);
             EXPECT_EQ(certs[1], clientIntCert_);
           }));
 
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("certverifyencoding")))
       .InSequence(contextSeq);
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain(), folly::none);
   EXPECT_EQ(state_.clientCert(), clientLeafCert_);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifyAlgoMismatch
	)

Definition at line 4175 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), fizz::ed25519, fizz::handshake_failure, and fizz::client::detail::processEvent().

                                                               {
   setUpExpectingCertificateVerify();
 
   context_->setSupportedSigSchemes({SignatureScheme::ed25519});
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzException>(
       actions,
       AlertDescription::handshake_failure,
       "client chose unsupported sig scheme:");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifySignatureFailure
	)

Definition at line 4189 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_record_mac, fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, testing::Invoke(), fizz::client::detail::processEvent(), and verify().

                                                                   {
   setUpExpectingCertificateVerify();
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq)
       .WillOnce(Throw(
           FizzException("verify failed", AlertDescription::bad_record_mac)));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzException>(
       actions, AlertDescription::bad_record_mac, "verify failed");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifyVerifierFailure
	)

Definition at line 4215 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_certificate, fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, testing::Invoke(), fizz::client::detail::processEvent(), and verify().

                                                                  {
   setUpExpectingCertificateVerify();
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq);
 
   EXPECT_CALL(*certVerifier_, verify(_))
       .InSequence(contextSeq)
       .WillOnce(Throw(FizzVerificationException(
           "verifier failed", AlertDescription::bad_certificate)));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzVerificationException>(
       actions, AlertDescription::bad_certificate, "verifier failed");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestOptionalCertificateVerifySignatureFailure
	)

Definition at line 4244 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_record_mac, fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, testing::Invoke(), fizz::client::detail::processEvent(), and verify().

                                                                           {
   setUpExpectingCertificateVerify();
   context_->setClientAuthMode(ClientAuthMode::Optional);
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq)
       .WillOnce(Throw(
           FizzException("verify failed", AlertDescription::bad_record_mac)));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzException>(
       actions, AlertDescription::bad_record_mac, "verify failed");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestOptionalCertificateVerifyVerifierFailure
	)

Definition at line 4271 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_certificate, fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, testing::Invoke(), fizz::client::detail::processEvent(), and verify().

                                                                          {
   setUpExpectingCertificateVerify();
   context_->setClientAuthMode(ClientAuthMode::Optional);
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq);
 
   EXPECT_CALL(*certVerifier_, verify(_))
       .InSequence(contextSeq)
       .WillOnce(Throw(
           FizzException("verifier failed", AlertDescription::bad_certificate)));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzException>(
       actions, AlertDescription::bad_certificate, "verifier failed");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestCertificateVerifyVerifierGenericFailure
	)

Definition at line 4301 of file ServerProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_certificate, fizz::test::TestMessages::certificateVerify(), fizz::Client, folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, testing::Invoke(), fizz::client::detail::processEvent(), and verify().

                                                                         {
   setUpExpectingCertificateVerify();
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
 
   EXPECT_CALL(
       *clientLeafCert_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Client,
           RangeMatches("certcontext"),
           RangeMatches("signature")))
       .InSequence(contextSeq);
 
   EXPECT_CALL(*certVerifier_, verify(_))
       .InSequence(contextSeq)
       .WillOnce(Throw(std::runtime_error("oops")));
 
   auto actions = getActions(
       detail::processEvent(state_, TestMessages::certificateVerify()));
 
   expectError<FizzException>(
       actions,
       AlertDescription::bad_certificate,
       "client certificate failure: oops");
 }

fizz::server::test::TEST_F	(	ServerProtocolTest	,
		TestEarlyWriteError
	)

Definition at line 4331 of file ServerProtocolTest.cpp.

References fizz::client::detail::actions(), and fizz::unexpected_message.

                                                 {
   setUpAcceptingData();
   auto actions = getActions(
       ServerStateMachine().processEarlyAppWrite(state_, EarlyAppWrite()));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "invalid event");
 }

static folly::ByteRange fizz::server::test::toRange ( const std::string & str )

static

Definition at line 38 of file SlidingBloomReplayCacheTest.cpp.

Referenced by TEST().

                                                     {
   return folly::ByteRange(folly::StringPiece(str));
 }

const std::vector<SignatureScheme> fizz::server::test::kRsa {SignatureScheme::rsa_pss_sha256}

static

Definition at line 24 of file CertManagerTest.cpp.

Referenced by TEST_F().

Classes
class	ActionMoveVisitor

class	AeadCookieCipherTest

class	AeadTicketCipherTest

class	AsyncFizzServerTest

class	CertManagerTest

class	FizzServerTest

class	FizzTestServer

class	GetCookieStateTest

class	MockAppTokenValidator

class	MockAsyncFizzServerT

class	MockCertManager

class	MockCookieCipher

class	MockHandshakeCallbackT

class	MockReplayCache

class	MockServerExtensions

class	MockServerStateMachine

class	MockServerStateMachineInstance

class	MockTicketCipher

class	MockTicketCodec

class	MockTicketCodecInstance

class	ServerProtocolTest

class	TestFizzServer

Typedefs
using	TestAeadTicketCipher = AeadTicketCipher< OpenSSLEVPCipher< AESGCM128 >, MockTicketCodec, HkdfImpl< Sha256 >>

using	MockHandshakeCallback = MockHandshakeCallbackT< ServerStateMachine >

using	MockAsyncFizzServer = MockAsyncFizzServerT< ServerStateMachine >

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation

Functions
	TEST_F (AeadCookieCipherTest, TestGetRetry)

	TEST_F (AeadCookieCipherTest, TestGetRetryGroup)

	TEST_F (AeadCookieCipherTest, TestGetToken)

	TEST_F (AeadCookieCipherTest, TestGetJunk)

	TEST_F (AeadCookieCipherTest, TestGetPartial)

	TEST_F (AeadCookieCipherTest, TestDecrypt)

	TEST_F (AeadCookieCipherTest, TestDecryptGroup)

	TEST_F (AeadCookieCipherTest, TestDecryptMultipleSecrets)

	TEST_F (AeadCookieCipherTest, TestDecryptFailed)

	TEST_F (AeadTicketCipherTest, TestEncryptNoTicketSecrets)

	TEST_F (AeadTicketCipherTest, TestEncrypt)

	TEST_F (AeadTicketCipherTest, TestDecryptNoTicketSecrets)

	TEST_F (AeadTicketCipherTest, TestDecryptFirst)

	TEST_F (AeadTicketCipherTest, TestDecryptSecond)

	TEST_F (AeadTicketCipherTest, TestDecryptWithContext)

	TEST_F (AeadTicketCipherTest, TestDecryptWithoutContext)

	TEST_F (AeadTicketCipherTest, TestDecryptWithWrongContext)

	TEST_F (AeadTicketCipherTest, TestDecryptWithUnneededContext)

	TEST_F (AeadTicketCipherTest, TestDecryptSeqNum)

	TEST_F (AeadTicketCipherTest, TestDecryptFailed)

	TEST_F (AeadTicketCipherTest, TestDecryptTooShort)

	TEST_F (AeadTicketCipherTest, TestUnsetTicketSecrets)

	TEST_F (AeadTicketCipherTest, TestSetTicketSecretsTooShort)

template<typename... Args>
AsyncActions	actions (Args &&...act)

	MATCHER_P (BufMatches, expected,"")

	TEST_F (AsyncFizzServerTest, TestAccept)

	TEST_F (AsyncFizzServerTest, TestReadSingle)

	TEST_F (AsyncFizzServerTest, TestReadMulti)

	TEST_F (AsyncFizzServerTest, TestWrite)

	TEST_F (AsyncFizzServerTest, TestWriteMulti)

	TEST_F (AsyncFizzServerTest, TestWriteErrorState)

	TEST_F (AsyncFizzServerTest, TestHandshake)

	TEST_F (AsyncFizzServerTest, TestExporterAPISimple)

	TEST_F (AsyncFizzServerTest, TestExporterAPIIncompleteHandshake)

	TEST_F (AsyncFizzServerTest, TestHandshakeError)

	TEST_F (AsyncFizzServerTest, TestDeliverAppData)

	TEST_F (AsyncFizzServerTest, TestWriteToSocket)

	TEST_F (AsyncFizzServerTest, TestMutateState)

	TEST_F (AsyncFizzServerTest, TestAttemptVersionFallback)

	TEST_F (AsyncFizzServerTest, TestDeleteAsyncEvent)

	TEST_F (AsyncFizzServerTest, TestCloseHandshake)

	TEST_F (AsyncFizzServerTest, TestCloseNowInFlightAction)

	TEST_F (AsyncFizzServerTest, TestCloseInFlightAction)

	TEST_F (AsyncFizzServerTest, TestIsDetachable)

	TEST_F (AsyncFizzServerTest, TestConnecting)

	TEST_F (AsyncFizzServerTest, TestGoodSocket)

	TEST_F (AsyncFizzServerTest, TestGoodState)

	TEST_F (AsyncFizzServerTest, TestEarlySuccess)

	TEST_F (AsyncFizzServerTest, TestErrorStopsActions)

	TEST_F (AsyncFizzServerTest, TestGetCertsNone)

	TEST_F (AsyncFizzServerTest, TestGetCerts)

	TEST_F (CertManagerTest, TestNoMatchDefault)

	TEST_F (CertManagerTest, TestNoSniDefault)

	TEST_F (CertManagerTest, TestWildcardDefault)

	TEST_F (CertManagerTest, TestUppercaseDefault)

	TEST_F (CertManagerTest, TestNoDefault)

	TEST_F (CertManagerTest, TestSigSchemesServerPref)

	TEST_F (CertManagerTest, TestClientSigScheme)

	TEST_F (CertManagerTest, TestClientSigSchemeWildcardMatch)

	TEST_F (CertManagerTest, TestClientSigSchemeFallback)

	TEST_F (CertManagerTest, TestAlts)

	TEST_F (CertManagerTest, TestWildcard)

	TEST_F (CertManagerTest, TestExactMatch)

	TEST_F (CertManagerTest, TestNoWildcard)

	TEST_F (CertManagerTest, TestGetByIdentity)

	TEST (GetStatelessHrrTest, NoGroup)

	TEST (GetStatelessHrrTest, Group)

	TEST_F (GetCookieStateTest, TestBasic)

	TEST_F (GetCookieStateTest, TestNoVersion)

	TEST_F (GetCookieStateTest, TestVersionMismatch)

	TEST_F (GetCookieStateTest, TestCipherNegotiate)

	TEST_F (GetCookieStateTest, TestCipherNegotiateTie)

	TEST_F (GetCookieStateTest, TestCipherMismatch)

	TEST_F (GetCookieStateTest, TestGroupNotSent)

	TEST_F (GetCookieStateTest, TestNoGroups)

	TEST_F (GetCookieStateTest, TestNoKeyShare)

	TEST_F (GetCookieStateTest, TestGroupMismatch)

	TEST (DualCipherTest, Encryption)

	TEST (DualCipherTest, DecryptSuccess)

	TEST (DualCipherTest, DecryptSuccessWithFallback)

	TEST_F (FizzServerTest, TestAccept)

static std::unique_ptr< IOBuf >	getV2ClientHello ()

	TEST_F (FizzServerTest, TestSSLV2)

	TEST_F (FizzServerTest, TestSSLV2NoVersionFallback)

	TEST_F (FizzServerTest, TestNotSSLV2)

	TEST_F (FizzServerTest, TestSSLV2AfterData)

	TEST (NegotiatorTest, TestSingle)

	TEST (NegotiatorTest, TestSingleMismatch)

	TEST (NegotiatorTest, TestServerPref)

	TEST (NegotiatorTest, TestServerPrefTie)

	TEST (NegotiateTest, TestSingleOrdering)

	TEST (NegotiateTest, TestSingleOrderingLast)

	TEST (NegotiateTest, TestSingleOrderingNoMatch)

	TEST (NegotiateTest, TestServerEmptyTier)

	TEST_F (ServerProtocolTest, TestInvalidTransitionNoAlert)

	TEST_F (ServerProtocolTest, TestInvalidTransitionAlert)

	TEST_F (ServerProtocolTest, TestInvalidTransitionError)

	TEST_F (ServerProtocolTest, TestAlertReceived)

	TEST_F (ServerProtocolTest, TestAccept)

	TEST_F (ServerProtocolTest, TestAppClose)

	TEST_F (ServerProtocolTest, TestAppCloseNoWrite)

	TEST_F (ServerProtocolTest, TestClientHelloFullHandshakeFlow)

	TEST_F (ServerProtocolTest, TestClientHelloCompressedCertFlow)

	TEST_F (ServerProtocolTest, TestClientHelloCertRequestFlow)

	TEST_F (ServerProtocolTest, TestClientHelloPskFlow)

	TEST_F (ServerProtocolTest, TestClientHelloPskDheFlow)

	TEST_F (ServerProtocolTest, TestClientHelloHelloRetryRequestFlow)

	TEST_F (ServerProtocolTest, TestRetryClientHelloFullHandshakeFlow)

	TEST_F (ServerProtocolTest, TestRetryClientHelloPskDheFlow)

	TEST_F (ServerProtocolTest, TestClientHelloPskDheEarlyFlow)

	TEST_F (ServerProtocolTest, TestClientHelloPskEarlyFlow)

	TEST_F (ServerProtocolTest, TestClientHelloNullExtensions)

	TEST_F (ServerProtocolTest, TestClientHelloLegacySessionId)

	TEST_F (ServerProtocolTest, TestClientHelloLegacyHrr)

	TEST_F (ServerProtocolTest, TestClientHelloFullHandshake)

	TEST_F (ServerProtocolTest, TestClientHelloPsk)

	TEST_F (ServerProtocolTest, TestClientHelloPskDhe)

	TEST_F (ServerProtocolTest, TestClientHelloPskModeMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloNoSni)

	TEST_F (ServerProtocolTest, TestClientHelloFullHandshakeRejectedPsk)

	TEST_F (ServerProtocolTest, TestClientHelloPskNoModes)

	TEST_F (ServerProtocolTest, TestClientHelloPskNotSupported)

	TEST_F (ServerProtocolTest, TestClientHelloPskBadBinder)

	TEST_F (ServerProtocolTest, TestClientHelloFallback)

	TEST_F (ServerProtocolTest, TestClientHelloNoSupportedVersions)

	TEST_F (ServerProtocolTest, TestClientHelloSupportedVersionsMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloCipherMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloNoSupportedGroups)

	TEST_F (ServerProtocolTest, TestClientHelloNamedGroupsMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloNoClientKeyShare)

	TEST_F (ServerProtocolTest, TestClientHelloNoSigScemes)

	TEST_F (ServerProtocolTest, TestClientHelloDataAfter)

	TEST_F (ServerProtocolTest, TestClientHelloNoAlpn)

	TEST_F (ServerProtocolTest, TestClientHelloAlpnMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloServerPref)

	TEST_F (ServerProtocolTest, TestClientHelloAcceptEarlyData)

	TEST_F (ServerProtocolTest, TestClientHelloEarlyDataNotAttemptedWithAppTokenValidator)

	TEST_F (ServerProtocolTest, TestClientHelloAcceptEarlyDataWithValidAppToken)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyData)

	TEST_F (ServerProtocolTest, TestClientHelloHrrRejectEarlyData)

	TEST_F (ServerProtocolTest, TestClientHelloCookieRejectEarlyData)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataPskRejected)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataReplayCache)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataNoAlpn)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataDiffAlpn)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataAfterHrr)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataClockBehind)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataClockAhead)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataTicketAgeOverflow)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataNegativeExpectedAge)

	TEST_F (ServerProtocolTest, TestClientHelloRejectEarlyDataInvalidAppToken)

	TEST_F (ServerProtocolTest, TestClientHelloHandshakeLogging)

	TEST_F (ServerProtocolTest, TestClientHelloHandshakeLoggingError)

	TEST_F (ServerProtocolTest, TestClientHelloNoCompressionMethods)

	TEST_F (ServerProtocolTest, TestClientHelloDuplicateExtensions)

	TEST_F (ServerProtocolTest, TestClientHelloDuplicateGroups)

	TEST_F (ServerProtocolTest, TestRetryClientHelloStillNoKeyShare)

	TEST_F (ServerProtocolTest, TestRetryClientHelloCookie)

	TEST_F (ServerProtocolTest, TestRetryClientHelloDifferentVersion)

	TEST_F (ServerProtocolTest, TestClientHelloRenegotiatePskCipher)

	TEST_F (ServerProtocolTest, TestClientHelloRenegotiatePskCipherIncompatible)

	TEST_F (ServerProtocolTest, TestClientHelloCookie)

	TEST_F (ServerProtocolTest, TestClientHelloCookieFail)

	TEST_F (ServerProtocolTest, TestClientHelloCookieNoCipher)

	TEST_F (ServerProtocolTest, TestClientHelloCookieVersionMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloCookieCipherMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloCookieGroupMismatch)

	TEST_F (ServerProtocolTest, TestClientHelloCookieNoGroup)

	TEST_F (ServerProtocolTest, TestNoCertCompressionAlgorithmMatch)

	TEST_F (ServerProtocolTest, TestCertCompressionRequestedNotSupported)

	TEST_F (ServerProtocolTest, TestEarlyAppData)

	TEST_F (ServerProtocolTest, TestEarlyAppWrite)

	TEST_F (ServerProtocolTest, TestEndOfEarlyData)

	TEST_F (ServerProtocolTest, TestEndOfEarlyDataExtraData)

	TEST_F (ServerProtocolTest, TestFullHandshakeFinished)

	TEST_F (ServerProtocolTest, TestFinishedNoTicket)

	TEST_F (ServerProtocolTest, TestFinishedTicketEarly)

	TEST_F (ServerProtocolTest, TestFinishedPskNotSupported)

	TEST_F (ServerProtocolTest, TestFinishedNoAutomaticNewSessionTicket)

	TEST_F (ServerProtocolTest, TestFinishedMismatch)

	TEST_F (ServerProtocolTest, TestFinishedExtraData)

	TEST_F (ServerProtocolTest, TestExpectingFinishedAppWrite)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicket)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicketWithTicketEarly)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicketWithAppToken)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicketWithAppTokenAfterAutomaticSend)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicketNoTicket)

	TEST_F (ServerProtocolTest, TestWriteNewSessionTicketPskNotSupported)

	TEST_F (ServerProtocolTest, TestAppData)

	TEST_F (ServerProtocolTest, TestAppWrite)

	TEST_F (ServerProtocolTest, TestKeyUpdateNotRequested)

	TEST_F (ServerProtocolTest, TestKeyUpdateExtraData)

	TEST_F (ServerProtocolTest, TestKeyUpdateRequest)

	TEST_F (ServerProtocolTest, TestCertificate)

	TEST_F (ServerProtocolTest, TestCertificateNonemptyContext)

	TEST_F (ServerProtocolTest, TestCertificateEmptyForbidden)

	TEST_F (ServerProtocolTest, TestCertificateEmptyPermitted)

	TEST_F (ServerProtocolTest, TestCertificateVerifyNoVerifier)

	TEST_F (ServerProtocolTest, TestCertificateVerifyWithVerifier)

	TEST_F (ServerProtocolTest, TestCertificateVerifyAlgoMismatch)

	TEST_F (ServerProtocolTest, TestCertificateVerifySignatureFailure)

	TEST_F (ServerProtocolTest, TestCertificateVerifyVerifierFailure)

	TEST_F (ServerProtocolTest, TestOptionalCertificateVerifySignatureFailure)

	TEST_F (ServerProtocolTest, TestOptionalCertificateVerifyVerifierFailure)

	TEST_F (ServerProtocolTest, TestCertificateVerifyVerifierGenericFailure)

	TEST_F (ServerProtocolTest, TestEarlyWriteError)

static std::string	generateRandomString (size_t minimum, size_t maximum)

static folly::ByteRange	toRange (const std::string &str)

	TEST (SlidingBloomReplayCacheTest, TestSimpleGetSet)

	TEST (SlidingBloomReplayCacheTest, TestSimpleTestAndSet)

	TEST (SlidingBloomReplayCacheTest, TestCacheErrorRate)

	TEST (SlidingBloomReplayCacheTest, TestTimeBucketing)

static ResumptionState	getTestResumptionState (std::shared_ptr< SelfCert > cert, std::shared_ptr< PeerCert > peerCert)

	TEST (TicketCodecTest, TestEncode)

	TEST (TicketCodecTest, TestEncodeWithAppToken)

	TEST (TicketCodecTest, TestEncodeNoAlpn)

	TEST (TicketCodecTest, TestEncodeClientAuthX509)

	TEST (TicketCodecTest, TestEncodeClientAuthIdentityOnly)

	TEST (TicketCodecTest, TestEncodeNoX509)

	TEST (TicketCodecTest, TestDecodeDifferentStorage)

	TEST (TicketCodecTest, TestDecode)

	TEST (TicketCodecTest, TestDecodeNoAlpn)

	TEST (TicketCodecTest, TestDecodeTooShort)

	TEST (TicketCodecTest, TestDecodeWithAppToken)

	TEST (TicketCodecTest, TestDecodeWithEmptyAppToken)

	TEST (TicketCodecTest, TestDecodeWithoutAppToken)

Variables
static const std::vector< SignatureScheme >	kRsa {SignatureScheme::rsa_pss_sha256}