From ccf8f083d882e69ba3badb24564f0891211ab4c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Amaury=20S=C3=A9chet?= Date: Wed, 26 Feb 2020 18:15:50 +0100 Subject: [PATCH] Add QuicPskCache to FizzClientQuicHandshakeContext --- .../FizzClientQuicHandshakeContext.cpp | 25 ++++++++-- .../FizzClientQuicHandshakeContext.h | 16 ++++++- .../handshake/test/ClientHandshakeTest.cpp | 11 +++++ quic/client/test/QuicClientTransportTest.cpp | 46 +++++++++++++++---- 4 files changed, 84 insertions(+), 14 deletions(-) diff --git a/quic/client/handshake/FizzClientQuicHandshakeContext.cpp b/quic/client/handshake/FizzClientQuicHandshakeContext.cpp index 47c7a3649..7eac0f8f1 100644 --- a/quic/client/handshake/FizzClientQuicHandshakeContext.cpp +++ b/quic/client/handshake/FizzClientQuicHandshakeContext.cpp @@ -14,8 +14,11 @@ namespace quic { FizzClientQuicHandshakeContext::FizzClientQuicHandshakeContext( std::shared_ptr context, - std::shared_ptr verifier) - : context_(std::move(context)), verifier_(std::move(verifier)) {} + std::shared_ptr verifier, + std::shared_ptr pskCache) + : context_(std::move(context)), + verifier_(std::move(verifier)), + pskCache_(std::move(pskCache)) {} std::unique_ptr FizzClientQuicHandshakeContext::makeClientHandshake( @@ -23,6 +26,22 @@ FizzClientQuicHandshakeContext::makeClientHandshake( return std::make_unique(conn, shared_from_this()); } +folly::Optional FizzClientQuicHandshakeContext::getPsk( + const folly::Optional& hostname) { + if (!hostname || !pskCache_) { + return folly::none; + } + + return pskCache_->getPsk(*hostname); +} + +void FizzClientQuicHandshakeContext::removePsk( + const folly::Optional& hostname) { + if (hostname && pskCache_) { + pskCache_->removePsk(*hostname); + } +} + std::shared_ptr FizzClientQuicHandshakeContext::Builder::build() { if (!context_) { @@ -35,7 +54,7 @@ FizzClientQuicHandshakeContext::Builder::build() { return std::shared_ptr( new FizzClientQuicHandshakeContext( - std::move(context_), std::move(verifier_))); + std::move(context_), std::move(verifier_), std::move(pskCache_))); } } // namespace quic diff --git a/quic/client/handshake/FizzClientQuicHandshakeContext.h b/quic/client/handshake/FizzClientQuicHandshakeContext.h index 9546b9566..56f85622e 100644 --- a/quic/client/handshake/FizzClientQuicHandshakeContext.h +++ b/quic/client/handshake/FizzClientQuicHandshakeContext.h @@ -10,6 +10,8 @@ #include +#include + #include #include @@ -34,6 +36,10 @@ class FizzClientQuicHandshakeContext return verifier_; } + folly::Optional getPsk( + const folly::Optional& hostname); + void removePsk(const folly::Optional& hostname); + private: /** * We make the constructor private so that users have to use the Builder @@ -45,10 +51,12 @@ class FizzClientQuicHandshakeContext */ FizzClientQuicHandshakeContext( std::shared_ptr context, - std::shared_ptr verifier); + std::shared_ptr verifier, + std::shared_ptr pskCache); std::shared_ptr context_; std::shared_ptr verifier_; + std::shared_ptr pskCache_; public: class Builder { @@ -65,11 +73,17 @@ class FizzClientQuicHandshakeContext return *this; } + Builder& setPskCache(std::shared_ptr pskCache) { + pskCache_ = std::move(pskCache); + return *this; + } + std::shared_ptr build(); private: std::shared_ptr context_; std::shared_ptr verifier_; + std::shared_ptr pskCache_; }; }; diff --git a/quic/client/handshake/test/ClientHandshakeTest.cpp b/quic/client/handshake/test/ClientHandshakeTest.cpp index 3f9a69725..bad20234d 100644 --- a/quic/client/handshake/test/ClientHandshakeTest.cpp +++ b/quic/client/handshake/test/ClientHandshakeTest.cpp @@ -88,6 +88,7 @@ class ClientHandshakeTest : public Test, public boost::static_visitor<> { auto handshakeFactory = FizzClientQuicHandshakeContext::Builder() .setFizzClientContext(clientCtx) .setCertificateVerifier(verifier) + .setPskCache(getPskCache()) .build(); conn.reset(new QuicClientConnectionState(handshakeFactory)); conn->readCodec = std::make_unique(QuicNodeType::Client); @@ -118,6 +119,10 @@ class ClientHandshakeTest : public Test, public boost::static_visitor<> { fizzServer->accept(&evb, serverCtx, serverTransportParameters); } + virtual std::shared_ptr getPskCache() { + return nullptr; + } + void clientServerRound() { auto writableBytes = getHandshakeWriteBytes(); serverReadBuf.append(std::move(writableBytes)); @@ -461,6 +466,12 @@ class ClientHandshakeZeroRttTest : public ClientHandshakeTest { setupZeroRttServer(); } + std::shared_ptr getPskCache() override { + auto pskCache = std::make_shared(); + pskCache->putPsk(hostname, psk); + return pskCache; + } + void connect() override { handshake->connect( hostname, diff --git a/quic/client/test/QuicClientTransportTest.cpp b/quic/client/test/QuicClientTransportTest.cpp index dcacba562..81004c769 100644 --- a/quic/client/test/QuicClientTransportTest.cpp +++ b/quic/client/test/QuicClientTransportTest.cpp @@ -220,6 +220,7 @@ class QuicClientTransportIntegrationTest : public TestWithParam { auto fizzClientContext = FizzClientQuicHandshakeContext::Builder() .setFizzClientContext(clientCtx) .setCertificateVerifier(verifier) + .setPskCache(pskCache_) .build(); client = std::make_shared( &eventbase_, @@ -1268,17 +1269,29 @@ class QuicClientTransportTest : public Test { QuicClientTransportTest() : eventbase_(std::make_unique()) {} + std::shared_ptr getFizzClientContext() { + if (!fizzClientContext) { + fizzClientContext = + FizzClientQuicHandshakeContext::Builder() + .setCertificateVerifier(createTestCertificateVerifier()) + .setPskCache(getPskCache()) + .build(); + } + + return fizzClientContext; + } + + virtual std::shared_ptr getPskCache() { + return nullptr; + } + void SetUp() override final { auto socket = std::make_unique>( eventbase_.get()); sock = socket.get(); - auto fizzClientContext = - FizzClientQuicHandshakeContext::Builder() - .setCertificateVerifier(createTestCertificateVerifier()) - .build(); client = TestingQuicClientTransport::newClient( - eventbase_.get(), std::move(socket), std::move(fizzClientContext)); + eventbase_.get(), std::move(socket), getFizzClientContext()); destructionCallback = std::make_shared(); client->setDestructionCallback(destructionCallback); client->setSupportedVersions( @@ -1324,8 +1337,8 @@ class QuicClientTransportTest : public Test { virtual void setupCryptoLayer() { // Fake that the handshake has already occured and fix the keys. - mockClientHandshake = - new FakeOneRttHandshakeLayer(&client->getNonConstConn()); + mockClientHandshake = new FakeOneRttHandshakeLayer( + &client->getNonConstConn()); client->getNonConstConn().clientHandshakeLayer = mockClientHandshake; client->getNonConstConn().handshakeLayer.reset(mockClientHandshake); setFakeHandshakeCiphers(); @@ -1663,6 +1676,7 @@ class QuicClientTransportTest : public Test { SocketAddress serverAddr{"127.0.0.1", 443}; AsyncUDPSocket::ReadCallback* networkReadCallback{nullptr}; FakeOneRttHandshakeLayer* mockClientHandshake; + std::shared_ptr fizzClientContext; std::shared_ptr client; PacketNum initialPacketNum{0}, handshakePacketNum{0}, appDataPacketNum{0}; std::unique_ptr connIdAlgo_; @@ -5071,11 +5085,15 @@ class QuicClientTransportPskCacheTest : public QuicClientTransportAfterStartTestBase { public: void SetUpChild() override { - mockPskCache_ = std::make_shared>(); client->setPskCache(mockPskCache_); QuicClientTransportAfterStartTestBase::SetUpChild(); } + std::shared_ptr getPskCache() override { + mockPskCache_ = std::make_shared>(); + return mockPskCache_; + } + protected: std::shared_ptr mockPskCache_; }; @@ -5164,12 +5182,16 @@ class QuicZeroRttClientTest : public QuicClientTransportAfterStartTestBase { test::createNoOpHeaderCipher()); } + std::shared_ptr getPskCache() override { + mockQuicPskCache_ = std::make_shared(); + return mockQuicPskCache_; + } + void start() override { TransportSettings clientSettings; // Ignore path mtu to test negotiation. clientSettings.canIgnorePathMTU = true; client->setTransportSettings(clientSettings); - mockQuicPskCache_ = std::make_shared>(); client->setPskCache(mockQuicPskCache_); } @@ -5433,7 +5455,6 @@ class QuicZeroRttHappyEyeballsClientTransportTest public: void SetUpChild() override { client->setHostname(hostname_); - mockQuicPskCache_ = std::make_shared>(); client->setPskCache(mockQuicPskCache_); auto secondSocket = @@ -5453,6 +5474,11 @@ class QuicZeroRttHappyEyeballsClientTransportTest setupCryptoLayer(); } + std::shared_ptr getPskCache() override { + mockQuicPskCache_ = std::make_shared(); + return mockQuicPskCache_; + } + protected: folly::test::MockAsyncUDPSocket* secondSock; SocketAddress firstAddress{"::1", 443};