fizz::client::test::ClientProtocolTest Class Reference

Inheritance diagram for fizz::client::test::ClientProtocolTest:

Public Member Functions
void	SetUp () override
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()

Protected Member Functions
void	setMockRecord ()
void	setMockHandshakeEncryptedRecord ()
void	setMockEarlyRecord ()
void	setMockContextAndScheduler ()
CachedPsk	getCachedPsk ()
EarlyDataParams	getEarlyDataParams ()
void	setupExpectingServerHello ()
void	setupExpectingServerHelloAfterHrr ()
void	setupExpectingEncryptedExtensions ()
void	setupExpectingEncryptedExtensionsEarlySent ()
void	setupExpectingCertificate ()
void	setupExpectingCertificateRequest ()
void	setupExpectingCertificateVerify ()
void	setupExpectingFinished ()
void	setupAcceptingData ()
void	doFinishedFlow (ClientAuthType authType)
Protected Member Functions inherited from fizz::test::ProtocolTest< ClientTypes, Actions >
void	expectActions (const Actions &actions)
T	expectAction (Actions &actions)
T	expectSingleAction (Actions actions)
void	processStateMutations (Actions &actions)
uint32_t	getNumActions (const Actions &actions, bool expectNonZero)
uint32_t	getNumActions (const Actions &actions, bool expectNonZero)
void	expectExceptionType (Actions &actions)
void	expectError (Actions &actions, folly::Optional< AlertDescription > alert, std::string msg="")
void	expectAeadCreation (std::map< std::string, MockAead ** > keys)
void	expectAeadCreation (MockAead **clientAead, MockAead **serverAead)
void	expectEncryptedReadRecordLayerCreation (MockEncryptedReadRecordLayer **recordLayer, MockAead **readAead, folly::ByteRange expectedBaseSecret, folly::Optional< bool > skipFailedDecryption=folly::none, Sequence *s=nullptr)
void	expectEncryptedWriteRecordLayerCreation (MockEncryptedWriteRecordLayer **recordLayer, MockAead **writeAead, folly::ByteRange expectedBaseSecret, std::function< TLSContent(TLSMessage &, MockEncryptedWriteRecordLayer *)> expectedWrite=nullptr, Sequence *s=nullptr)
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()

Static Protected Member Functions
static ClientHello	getDefaultClientHello ()

Protected Attributes
std::shared_ptr< FizzClientContext >	context_
MockPlaintextReadRecordLayer *	mockRead_
MockPlaintextWriteRecordLayer *	mockWrite_
MockEncryptedWriteRecordLayer *	mockEarlyWrite_
MockEncryptedWriteRecordLayer *	mockHandshakeWrite_
MockEncryptedReadRecordLayer *	mockHandshakeRead_
MockKeyExchange *	mockKex_
MockKeyScheduler *	mockKeyScheduler_
MockHandshakeContext *	mockHandshakeContext_
std::shared_ptr< MockPeerCert >	mockLeaf_
std::shared_ptr< MockPeerCert >	mockIntermediate_
std::shared_ptr< MockSelfCert >	mockClientCert_
std::shared_ptr< MockCertificateVerifier >	verifier_
std::shared_ptr< MockPskCache >	pskCache_
Protected Attributes inherited from fizz::test::ProtocolTest< ClientTypes, Actions >
ClientTypes::State	state_
MockFactory *	factory_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
Protected Types inherited from fizz::test::ProtocolTest< ClientTypes, Actions >
using	MutateState = folly::Function< void(typename ClientTypes::State &)>

Detailed Description

Definition at line 28 of file ClientProtocolTest.cpp.

Member Function Documentation

void fizz::client::test::ClientProtocolTest::doFinishedFlow ( ClientAuthType  authType )

protected

Definition at line 2591 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::certificateVerify(), fizz::Client, fizz::ClientAppTraffic, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::ecdsa_secp256r1_sha256, fizz::encodeHandshake(), 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::client::detail::processEvent(), fizz::ResumptionMaster, fizz::ServerAppTraffic, fizz::TLSMessage::type, and fizz::detail::write().

                                                               {
  Sequence contextSeq;
  EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
      .InSequence(contextSeq)
      .WillOnce(
          InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
  EXPECT_CALL(
      *mockHandshakeContext_,
      appendToTranscript(BufMatches("finishedencoding")))
      .InSequence(contextSeq);
  EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
      .InSequence(contextSeq)
      .WillRepeatedly(
          Invoke([]() { return IOBuf::copyBuffer("sfincontext"); }));
  if (authType != ClientAuthType::NotRequested) {
    if (authType == ClientAuthType::Sent) {
      EXPECT_CALL(*mockClientCert_, _getCertMessage(_))
          .InSequence(contextSeq)
          .WillOnce(
              InvokeWithoutArgs([]() { return TestMessages::certificate(); }));
    }
    EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
        .InSequence(contextSeq)
        .WillOnce(Invoke([authType](const Buf& enc) {
          if (authType == ClientAuthType::Sent) {
            EXPECT_TRUE(IOBufEqualTo()(
                enc, encodeHandshake(TestMessages::certificate())));
          } else {
            EXPECT_TRUE(IOBufEqualTo()(enc, encodeHandshake(CertificateMsg())));
          }
        }));
    if (authType == ClientAuthType::Sent) {
      EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
          .InSequence(contextSeq)
          .WillRepeatedly(
              Invoke([]() { return IOBuf::copyBuffer("csentcontext"); }));
      EXPECT_CALL(
          *mockClientCert_,
          sign(
              SignatureScheme::ecdsa_secp256r1_sha256,
              CertificateVerifyContext::Client,
              RangeMatches("csentcontext")))
          .InSequence(contextSeq)
          .WillOnce(InvokeWithoutArgs(
              []() { return IOBuf::copyBuffer("signature"); }));
      EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
          .InSequence(contextSeq)
          .WillOnce(Invoke([](const Buf& enc) {
            EXPECT_TRUE(IOBufEqualTo()(
                enc, encodeHandshake(TestMessages::certificateVerify())));
          }));
    }
  }
  EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("cht")))
      .InSequence(contextSeq)
      .WillRepeatedly(
          InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
  EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
      .InSequence(contextSeq);
  EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
      .InSequence(contextSeq)
      .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("fincontext"); }));
  EXPECT_CALL(*mockHandshakeWrite_, _write(_))
      .WillOnce(Invoke([&](TLSMessage& msg) {
        TLSContent content;
        content.contentType = msg.type;
        content.encryptionLevel = mockHandshakeWrite_->getEncryptionLevel();
        EXPECT_EQ(msg.type, ContentType::handshake);

        switch (authType) {
          case ClientAuthType::NotRequested:
          case ClientAuthType::Stored:
            EXPECT_TRUE(IOBufEqualTo()(
                msg.fragment, encodeHandshake(TestMessages::finished())));
            break;
          case ClientAuthType::RequestedNoMatch: {
            auto expectedMessages = encodeHandshake(CertificateMsg());
            expectedMessages->prependChain(
                encodeHandshake(TestMessages::finished()));
            EXPECT_TRUE(IOBufEqualTo()(msg.fragment, expectedMessages));
            break;
          }
          case ClientAuthType::Sent: {
            auto expectedMessages =
                encodeHandshake(TestMessages::certificate());
            expectedMessages->prependChain(
                encodeHandshake(TestMessages::certificateVerify()));
            expectedMessages->prependChain(
                encodeHandshake(TestMessages::finished()));
            EXPECT_TRUE(IOBufEqualTo()(msg.fragment, expectedMessages));
            break;
          }
        }
        content.data = folly::IOBuf::copyBuffer("finwrite");
        return content;
      }));
  EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
  EXPECT_CALL(
      *mockKeyScheduler_,
      getSecret(MasterSecrets::ExporterMaster, RangeMatches("sfincontext")));
  EXPECT_CALL(
      *mockKeyScheduler_,
      getSecret(MasterSecrets::ResumptionMaster, RangeMatches("fincontext")))
      .WillOnce(InvokeWithoutArgs([]() {
        return std::vector<uint8_t>({'r', 'e', 's'});
      }));
  EXPECT_CALL(
      *mockKeyScheduler_, deriveAppTrafficSecrets(RangeMatches("sfincontext")));
  EXPECT_CALL(
      *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
      .WillOnce(InvokeWithoutArgs([]() {
        return std::vector<uint8_t>({'s', 'a', 't'});
      }));
  EXPECT_CALL(
      *mockKeyScheduler_, getSecret(AppTrafficSecrets::ClientAppTraffic))
      .WillOnce(InvokeWithoutArgs([]() {
        return std::vector<uint8_t>({'c', 'a', 't'});
      }));
  EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
      .WillOnce(InvokeWithoutArgs([]() {
        return TrafficKey{IOBuf::copyBuffer("serverkey"),
                          IOBuf::copyBuffer("serveriv")};
      }));
  EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cat"), _, _))
      .WillOnce(InvokeWithoutArgs([]() {
        return TrafficKey{IOBuf::copyBuffer("clientkey"),
                          IOBuf::copyBuffer("clientiv")};
      }));
  MockAead* raead;
  MockAead* waead;
  MockEncryptedReadRecordLayer* rrl;
  MockEncryptedWriteRecordLayer* wrl;
  expectAeadCreation(&waead, &raead);
  expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sat"));
  expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cat"));
  EXPECT_CALL(*mockKeyScheduler_, clearMasterSecret());

  auto actions = detail::processEvent(state_, TestMessages::finished());
  expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
  auto write = expectAction<WriteToSocket>(actions);
  EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Handshake);
  EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
  EXPECT_TRUE(
      IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("finwrite")));
  auto reportSuccess = expectAction<ReportHandshakeSuccess>(actions);
  EXPECT_EQ(reportSuccess.earlyDataAccepted, false);
  processStateMutations(actions);
  EXPECT_EQ(state_.readRecordLayer().get(), rrl);
  EXPECT_EQ(
      state_.readRecordLayer()->getEncryptionLevel(),
      EncryptionLevel::AppTraffic);
  EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
  EXPECT_EQ(
      state_.writeRecordLayer()->getEncryptionLevel(),
      EncryptionLevel::AppTraffic);
  EXPECT_EQ(state_.state(), StateEnum::Established);
  EXPECT_TRUE(
      IOBufEqualTo()(*state_.resumptionSecret(), IOBuf::copyBuffer("res")));
  EXPECT_FALSE(state_.sentCCS());
}

CachedPsk fizz::client::test::ClientProtocolTest::getCachedPsk ( )

inlineprotected

Definition at line 89 of file ClientProtocolTest.cpp.

References fizz::client::CachedPsk::clientCert, fizz::client::test::getTestPsk(), now(), and fizz::client::CachedPsk::serverCert.

                           {
    CachedPsk psk = getTestPsk("PSK", std::chrono::system_clock::now());
    psk.serverCert = mockLeaf_;
    psk.clientCert = mockClientCert_;
    return psk;
  }

static ClientHello fizz::client::test::ClientProtocolTest::getDefaultClientHello ( )

inlinestaticprotected

Definition at line 85 of file ClientProtocolTest.cpp.

References fizz::test::TestMessages::clientHello().

                                             {
    return TestMessages::clientHello();
  }

EarlyDataParams fizz::client::test::ClientProtocolTest::getEarlyDataParams ( )

inlineprotected

Definition at line 96 of file ClientProtocolTest.cpp.

References fizz::client::EarlyDataParams::alpn, fizz::client::EarlyDataParams::cipher, fizz::client::EarlyDataParams::clientCert, folly::IOBuf::copyBuffer(), fizz::client::EarlyDataParams::earlyExporterSecret, params, fizz::client::EarlyDataParams::serverCert, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::client::EarlyDataParams::version.

                                       {
    EarlyDataParams params;
    params.version = TestProtocolVersion;
    params.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
    params.serverCert = mockLeaf_;
    params.clientCert = mockClientCert_;
    params.alpn = "h2";
    params.earlyExporterSecret = IOBuf::copyBuffer("earlyexporter");
    return params;
  }

void fizz::client::test::ClientProtocolTest::setMockContextAndScheduler ( )

inlineprotected

Definition at line 74 of file ClientProtocolTest.cpp.

References folly::gen::move.

                                    {
    auto handshakeContext = std::make_unique<MockHandshakeContext>();
    mockHandshakeContext_ = handshakeContext.get();
    mockHandshakeContext_->setDefaults();
    state_.handshakeContext() = std::move(handshakeContext);
    auto keyScheduler = std::make_unique<MockKeyScheduler>();
    mockKeyScheduler_ = keyScheduler.get();
    mockKeyScheduler_->setDefaults();
    state_.keyScheduler() = std::move(keyScheduler);
  }

void fizz::client::test::ClientProtocolTest::setMockEarlyRecord ( )

inlineprotected

Definition at line 67 of file ClientProtocolTest.cpp.

References fizz::EarlyData.

                            {
    mockEarlyWrite_ =
        new MockEncryptedWriteRecordLayer(EncryptionLevel::EarlyData);
    mockEarlyWrite_->setDefaults();
    state_.earlyWriteRecordLayer().reset(mockEarlyWrite_);
  }

void fizz::client::test::ClientProtocolTest::setMockHandshakeEncryptedRecord ( )

inlineprotected

Definition at line 57 of file ClientProtocolTest.cpp.

References fizz::Handshake.

                                         {
    mockHandshakeRead_ =
        new MockEncryptedReadRecordLayer(EncryptionLevel::Handshake);
    mockHandshakeWrite_ =
        new MockEncryptedWriteRecordLayer(EncryptionLevel::Handshake);
    mockHandshakeWrite_->setDefaults();
    state_.readRecordLayer().reset(mockHandshakeRead_);
    state_.writeRecordLayer().reset(mockHandshakeWrite_);
  }

void fizz::client::test::ClientProtocolTest::setMockRecord ( )

inlineprotected

Definition at line 49 of file ClientProtocolTest.cpp.

                       {
    mockRead_ = new MockPlaintextReadRecordLayer();
    mockWrite_ = new MockPlaintextWriteRecordLayer();
    mockWrite_->setDefaults();
    state_.readRecordLayer().reset(mockRead_);
    state_.writeRecordLayer().reset(mockWrite_);
  }

void fizz::client::test::ClientProtocolTest::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 30 of file ClientProtocolTest.cpp.

References folly::gen::move, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, fizz::TLS_AES_256_GCM_SHA384, and verifier_.

                        {
    context_ = std::make_shared<FizzClientContext>();
    context_->setSupportedVersions({ProtocolVersion::tls_1_3});
    context_->setSupportedCiphers({CipherSuite::TLS_AES_128_GCM_SHA256,
                                   CipherSuite::TLS_AES_256_GCM_SHA384});
    auto mockFactory = std::make_unique<MockFactory>();
    mockFactory->setDefaults();
    factory_ = mockFactory.get();
    context_->setFactory(std::move(mockFactory));
    context_->setSupportedAlpns({"h2"});
    verifier_ = std::make_shared<MockCertificateVerifier>();
    pskCache_ = std::make_shared<MockPskCache>();
    context_->setPskCache(pskCache_);
    context_->setSendEarlyData(true);
    mockLeaf_ = std::make_shared<MockPeerCert>();
    mockClientCert_ = std::make_shared<MockSelfCert>();
  }

void fizz::client::test::ClientProtocolTest::setupAcceptingData ( )

inlineprotected

Definition at line 225 of file ClientProtocolTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                            {
    setMockRecord();
    setMockContextAndScheduler();
    state_.version() = ProtocolVersion::tls_1_3;
    state_.cipher() = CipherSuite::TLS_AES_128_GCM_SHA256;
    state_.group() = NamedGroup::x25519;
    state_.context() = context_;
    state_.state() = StateEnum::Established;
    state_.resumptionSecret() = IOBuf::copyBuffer("resumptionsecret");
    state_.sni() = "www.hostname.com";
    state_.serverCert() = mockLeaf_;
  }

void fizz::client::test::ClientProtocolTest::setupExpectingCertificate ( )

inlineprotected

Definition at line 182 of file ClientProtocolTest.cpp.

                                   {
    setMockRecord();
    setMockContextAndScheduler();
    state_.context() = context_;
    state_.state() = StateEnum::ExpectingCertificate;
  }

void fizz::client::test::ClientProtocolTest::setupExpectingCertificateRequest ( )

inlineprotected

Definition at line 189 of file ClientProtocolTest.cpp.

                                          {
    setMockRecord();
    setMockContextAndScheduler();
    context_->setClientCertificate(mockClientCert_);
    state_.context() = context_;
    state_.state() = StateEnum::ExpectingCertificate;
  }

void fizz::client::test::ClientProtocolTest::setupExpectingCertificateVerify ( )

inlineprotected

Definition at line 197 of file ClientProtocolTest.cpp.

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

                                         {
    setMockRecord();
    setMockContextAndScheduler();
    state_.context() = context_;
    state_.verifier() = verifier_;
    mockIntermediate_ = std::make_shared<MockPeerCert>();
    std::vector<std::shared_ptr<const PeerCert>> certs;
    certs.push_back(mockLeaf_);
    certs.push_back(mockIntermediate_);
    state_.unverifiedCertChain() = std::move(certs);
    state_.state() = StateEnum::ExpectingCertificateVerify;
    state_.clientAuthRequested() = ClientAuthType::NotRequested;
  }

void fizz::client::test::ClientProtocolTest::setupExpectingEncryptedExtensions ( )

inlineprotected

Definition at line 155 of file ClientProtocolTest.cpp.

References fizz::application_layer_protocol_negotiation, fizz::early_data, fizz::key_share, fizz::key_share_old, fizz::NotAttempted, fizz::pre_shared_key, fizz::server_name, fizz::supported_versions, fizz::test::TestProtocolVersion, and fizz::TLS_AES_128_GCM_SHA256.

                                           {
    setMockRecord();
    setMockContextAndScheduler();
    state_.context() = context_;
    state_.earlyDataType() = EarlyDataType::NotAttempted;
    state_.version() = TestProtocolVersion;
    state_.cipher() = CipherSuite::TLS_AES_128_GCM_SHA256;
    state_.state() = StateEnum::ExpectingEncryptedExtensions;
    state_.requestedExtensions() = std::vector<ExtensionType>(
        {ExtensionType::supported_versions,
         ExtensionType::key_share,
         ExtensionType::key_share_old,
         ExtensionType::server_name,
         ExtensionType::application_layer_protocol_negotiation,
         ExtensionType::pre_shared_key,
         ExtensionType::early_data});
  }

void fizz::client::test::ClientProtocolTest::setupExpectingEncryptedExtensionsEarlySent ( )

inlineprotected

Definition at line 173 of file ClientProtocolTest.cpp.

References fizz::Attempted, fizz::sm::getEarlyDataParams(), and fizz::Resumption.

                                                    {
    setupExpectingEncryptedExtensions();
    setMockEarlyRecord();
    state_.attemptedPsk() = getCachedPsk();
    state_.pskType() = PskType::Resumption;
    state_.earlyDataType() = EarlyDataType::Attempted;
    state_.earlyDataParams() = getEarlyDataParams();
  }

void fizz::client::test::ClientProtocolTest::setupExpectingFinished ( )

inlineprotected

Definition at line 211 of file ClientProtocolTest.cpp.

References folly::IOBuf::copyBuffer(), fizz::NotAttempted, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                {
    setMockHandshakeEncryptedRecord();
    setMockContextAndScheduler();
    state_.context() = context_;
    state_.version() = TestProtocolVersion;
    state_.cipher() = CipherSuite::TLS_AES_128_GCM_SHA256;
    state_.group() = NamedGroup::x25519;
    state_.clientHandshakeSecret() = IOBuf::copyBuffer("cht");
    state_.serverHandshakeSecret() = IOBuf::copyBuffer("sht");
    state_.state() = StateEnum::ExpectingFinished;
    state_.clientAuthRequested() = ClientAuthType::NotRequested;
    state_.earlyDataType() = EarlyDataType::NotAttempted;
  }

void fizz::client::test::ClientProtocolTest::setupExpectingServerHello ( )

inlineprotected

Definition at line 107 of file ClientProtocolTest.cpp.

References fizz::application_layer_protocol_negotiation, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::early_data, fizz::key_share, fizz::key_share_old, folly::gen::move, fizz::NotAttempted, fizz::pre_shared_key, random(), fizz::server_name, fizz::supported_versions, verifier_, and fizz::x25519.

                                   {
    setMockRecord();
    state_.context() = context_;
    state_.encodedClientHello() = IOBuf::copyBuffer("chlo");
    auto mockKex = std::make_unique<MockKeyExchange>();
    mockKex_ = mockKex.get();
    mockKex_->setDefaults();
    std::map<NamedGroup, std::unique_ptr<KeyExchange>> kexs;
    kexs.emplace(NamedGroup::x25519, std::move(mockKex));
    state_.keyExchangers() = std::move(kexs);
    Random random;
    random.fill(0x44);
    state_.clientRandom() = std::move(random);
    state_.legacySessionId() = IOBuf::create(0);
    state_.sni() = "www.hostname.com";
    state_.verifier() = verifier_;
    state_.earlyDataType() = EarlyDataType::NotAttempted;
    state_.state() = StateEnum::ExpectingServerHello;
    state_.requestedExtensions() = std::vector<ExtensionType>(
        {ExtensionType::supported_versions,
         ExtensionType::key_share,
         ExtensionType::key_share_old,
         ExtensionType::server_name,
         ExtensionType::application_layer_protocol_negotiation,
         ExtensionType::pre_shared_key,
         ExtensionType::early_data});
  }

void fizz::client::test::ClientProtocolTest::setupExpectingServerHelloAfterHrr ( )

inlineprotected

Definition at line 135 of file ClientProtocolTest.cpp.

References fizz::application_layer_protocol_negotiation, fizz::early_data, fizz::HelloRetryRequest, fizz::key_share, fizz::key_share_old, folly::gen::move, fizz::pre_shared_key, fizz::server_name, fizz::supported_versions, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                           {
    setupExpectingServerHello();
    state_.keyExchangeType() = KeyExchangeType::HelloRetryRequest;
    auto handshakeContext = std::make_unique<MockHandshakeContext>();
    mockHandshakeContext_ = handshakeContext.get();
    mockHandshakeContext_->setDefaults();
    state_.handshakeContext() = std::move(handshakeContext);
    state_.version() = TestProtocolVersion;
    state_.cipher() = CipherSuite::TLS_AES_128_GCM_SHA256;
    state_.group() = NamedGroup::x25519;
    state_.requestedExtensions() = std::vector<ExtensionType>(
        {ExtensionType::supported_versions,
         ExtensionType::key_share,
         ExtensionType::key_share_old,
         ExtensionType::server_name,
         ExtensionType::application_layer_protocol_negotiation,
         ExtensionType::pre_shared_key,
         ExtensionType::early_data});
  }

Member Data Documentation

std::shared_ptr<FizzClientContext> fizz::client::test::ClientProtocolTest::context_

protected

Definition at line 240 of file ClientProtocolTest.cpp.

std::shared_ptr<MockSelfCert> fizz::client::test::ClientProtocolTest::mockClientCert_

protected

Definition at line 251 of file ClientProtocolTest.cpp.

MockEncryptedWriteRecordLayer* fizz::client::test::ClientProtocolTest::mockEarlyWrite_

protected

Definition at line 243 of file ClientProtocolTest.cpp.

MockHandshakeContext* fizz::client::test::ClientProtocolTest::mockHandshakeContext_

protected

Definition at line 248 of file ClientProtocolTest.cpp.

MockEncryptedReadRecordLayer* fizz::client::test::ClientProtocolTest::mockHandshakeRead_

protected

Definition at line 245 of file ClientProtocolTest.cpp.

MockEncryptedWriteRecordLayer* fizz::client::test::ClientProtocolTest::mockHandshakeWrite_

protected

Definition at line 244 of file ClientProtocolTest.cpp.

std::shared_ptr<MockPeerCert> fizz::client::test::ClientProtocolTest::mockIntermediate_

protected

Definition at line 250 of file ClientProtocolTest.cpp.

MockKeyExchange* fizz::client::test::ClientProtocolTest::mockKex_

protected

Definition at line 246 of file ClientProtocolTest.cpp.

MockKeyScheduler* fizz::client::test::ClientProtocolTest::mockKeyScheduler_

protected

Definition at line 247 of file ClientProtocolTest.cpp.

std::shared_ptr<MockPeerCert> fizz::client::test::ClientProtocolTest::mockLeaf_

protected

Definition at line 249 of file ClientProtocolTest.cpp.

MockPlaintextReadRecordLayer* fizz::client::test::ClientProtocolTest::mockRead_

protected

Definition at line 241 of file ClientProtocolTest.cpp.

MockPlaintextWriteRecordLayer* fizz::client::test::ClientProtocolTest::mockWrite_

protected

Definition at line 242 of file ClientProtocolTest.cpp.

std::shared_ptr<MockPskCache> fizz::client::test::ClientProtocolTest::pskCache_

protected

Definition at line 253 of file ClientProtocolTest.cpp.

std::shared_ptr<MockCertificateVerifier> fizz::client::test::ClientProtocolTest::verifier_

protected

Definition at line 252 of file ClientProtocolTest.cpp.

---

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

• proxygen/fizz/fizz/client/test/ClientProtocolTest.cpp