blob: 2a620469b5a2803efe2be8604614c9acf68e4a15 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "quic/core/http/quic_spdy_client_session.h"
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "absl/base/macros.h"
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quic/core/crypto/null_decrypter.h"
#include "quic/core/crypto/null_encrypter.h"
#include "quic/core/http/http_constants.h"
#include "quic/core/http/http_frames.h"
#include "quic/core/http/quic_spdy_client_stream.h"
#include "quic/core/http/spdy_server_push_utils.h"
#include "quic/core/quic_constants.h"
#include "quic/core/quic_error_codes.h"
#include "quic/core/quic_utils.h"
#include "quic/core/quic_versions.h"
#include "quic/core/tls_client_handshaker.h"
#include "quic/platform/api/quic_expect_bug.h"
#include "quic/platform/api/quic_flags.h"
#include "quic/platform/api/quic_socket_address.h"
#include "quic/platform/api/quic_test.h"
#include "quic/test_tools/crypto_test_utils.h"
#include "quic/test_tools/mock_quic_spdy_client_stream.h"
#include "quic/test_tools/quic_config_peer.h"
#include "quic/test_tools/quic_connection_peer.h"
#include "quic/test_tools/quic_framer_peer.h"
#include "quic/test_tools/quic_packet_creator_peer.h"
#include "quic/test_tools/quic_session_peer.h"
#include "quic/test_tools/quic_spdy_session_peer.h"
#include "quic/test_tools/quic_stream_peer.h"
#include "quic/test_tools/quic_test_utils.h"
#include "quic/test_tools/simple_session_cache.h"
using spdy::SpdyHeaderBlock;
using ::testing::_;
using ::testing::AnyNumber;
using ::testing::AtLeast;
using ::testing::AtMost;
using ::testing::Invoke;
using ::testing::StrictMock;
using ::testing::Truly;
namespace quic {
namespace test {
namespace {
const char kServerHostname[] = "test.example.com";
const uint16_t kPort = 443;
class TestQuicSpdyClientSession : public QuicSpdyClientSession {
public:
explicit TestQuicSpdyClientSession(
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicConnection* connection,
const QuicServerId& server_id,
QuicCryptoClientConfig* crypto_config,
QuicClientPushPromiseIndex* push_promise_index)
: QuicSpdyClientSession(config,
supported_versions,
connection,
server_id,
crypto_config,
push_promise_index) {}
std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override {
return std::make_unique<MockQuicSpdyClientStream>(
GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL);
}
MockQuicSpdyClientStream* CreateIncomingStream(QuicStreamId id) override {
if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
MockQuicSpdyClientStream* stream =
new MockQuicSpdyClientStream(id, this, READ_UNIDIRECTIONAL);
ActivateStream(absl::WrapUnique(stream));
return stream;
}
};
class QuicSpdyClientSessionTest : public QuicTestWithParam<ParsedQuicVersion> {
protected:
QuicSpdyClientSessionTest()
: promised_stream_id_(
QuicUtils::GetInvalidStreamId(GetParam().transport_version)),
associated_stream_id_(
QuicUtils::GetInvalidStreamId(GetParam().transport_version)) {
auto client_cache = std::make_unique<test::SimpleSessionCache>();
client_session_cache_ = client_cache.get();
client_crypto_config_ = std::make_unique<QuicCryptoClientConfig>(
crypto_test_utils::ProofVerifierForTesting(), std::move(client_cache));
server_crypto_config_ = crypto_test_utils::CryptoServerConfigForTesting();
Initialize();
// Advance the time, because timers do not like uninitialized times.
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
}
~QuicSpdyClientSessionTest() override {
// Session must be destroyed before promised_by_url_
session_.reset(nullptr);
}
void Initialize() {
session_.reset();
connection_ = new ::testing::NiceMock<PacketSavingConnection>(
&helper_, &alarm_factory_, Perspective::IS_CLIENT,
SupportedVersions(GetParam()));
session_ = std::make_unique<TestQuicSpdyClientSession>(
DefaultQuicConfig(), SupportedVersions(GetParam()), connection_,
QuicServerId(kServerHostname, kPort, false),
client_crypto_config_.get(), &push_promise_index_);
session_->Initialize();
connection_->SetEncrypter(
ENCRYPTION_FORWARD_SECURE,
std::make_unique<NullEncrypter>(connection_->perspective()));
crypto_stream_ = static_cast<QuicCryptoClientStream*>(
session_->GetMutableCryptoStream());
push_promise_[":path"] = "/bar";
push_promise_[":authority"] = "www.google.com";
push_promise_[":method"] = "GET";
push_promise_[":scheme"] = "https";
promise_url_ =
SpdyServerPushUtils::GetPromisedUrlFromHeaders(push_promise_);
promised_stream_id_ = GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 0);
associated_stream_id_ = GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0);
}
// The function ensures that A) the MAX_STREAMS frames get properly deleted
// (since the test uses a 'did we leak memory' check ... if we just lose the
// frame, the test fails) and B) returns true (instead of the default, false)
// which ensures that the rest of the system thinks that the frame actually
// was transmitted.
bool ClearMaxStreamsControlFrame(const QuicFrame& frame) {
if (frame.type == MAX_STREAMS_FRAME) {
DeleteFrame(&const_cast<QuicFrame&>(frame));
return true;
}
return false;
}
public:
bool ClearStreamsBlockedControlFrame(const QuicFrame& frame) {
if (frame.type == STREAMS_BLOCKED_FRAME) {
DeleteFrame(&const_cast<QuicFrame&>(frame));
return true;
}
return false;
}
protected:
void CompleteCryptoHandshake() {
CompleteCryptoHandshake(kDefaultMaxStreamsPerConnection);
}
void CompleteCryptoHandshake(uint32_t server_max_incoming_streams) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(::testing::AnyNumber())
.WillRepeatedly(Invoke(
this, &QuicSpdyClientSessionTest::ClearMaxStreamsControlFrame));
}
session_->CryptoConnect();
QuicConfig config = DefaultQuicConfig();
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
config.SetMaxUnidirectionalStreamsToSend(server_max_incoming_streams);
config.SetMaxBidirectionalStreamsToSend(server_max_incoming_streams);
} else {
config.SetMaxBidirectionalStreamsToSend(server_max_incoming_streams);
}
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
}
void CreateConnection() {
connection_ = new ::testing::NiceMock<PacketSavingConnection>(
&helper_, &alarm_factory_, Perspective::IS_CLIENT,
SupportedVersions(GetParam()));
// Advance the time, because timers do not like uninitialized times.
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
session_ = std::make_unique<TestQuicSpdyClientSession>(
DefaultQuicConfig(), SupportedVersions(GetParam()), connection_,
QuicServerId(kServerHostname, kPort, false),
client_crypto_config_.get(), &push_promise_index_);
session_->Initialize();
crypto_stream_ = static_cast<QuicCryptoClientStream*>(
session_->GetMutableCryptoStream());
}
void CompleteFirstConnection() {
CompleteCryptoHandshake();
EXPECT_FALSE(session_->GetCryptoStream()->IsResumption());
if (session_->version().UsesHttp3()) {
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 2;
settings.values[SETTINGS_MAX_FIELD_SECTION_SIZE] = 5;
settings.values[256] = 4; // unknown setting
session_->OnSettingsFrame(settings);
}
}
// Owned by |session_|.
QuicCryptoClientStream* crypto_stream_;
std::unique_ptr<QuicCryptoServerConfig> server_crypto_config_;
std::unique_ptr<QuicCryptoClientConfig> client_crypto_config_;
MockQuicConnectionHelper helper_;
MockAlarmFactory alarm_factory_;
::testing::NiceMock<PacketSavingConnection>* connection_;
std::unique_ptr<TestQuicSpdyClientSession> session_;
QuicClientPushPromiseIndex push_promise_index_;
SpdyHeaderBlock push_promise_;
std::string promise_url_;
QuicStreamId promised_stream_id_;
QuicStreamId associated_stream_id_;
test::SimpleSessionCache* client_session_cache_;
};
std::string ParamNameFormatter(
const testing::TestParamInfo<QuicSpdyClientSessionTest::ParamType>& info) {
return ParsedQuicVersionToString(info.param);
}
INSTANTIATE_TEST_SUITE_P(Tests,
QuicSpdyClientSessionTest,
::testing::ValuesIn(AllSupportedVersions()),
ParamNameFormatter);
TEST_P(QuicSpdyClientSessionTest, CryptoConnect) {
CompleteCryptoHandshake();
}
TEST_P(QuicSpdyClientSessionTest, NoEncryptionAfterInitialEncryption) {
if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
// This test relies on resumption and is QUIC crypto specific, so it is
// disabled for TLS.
return;
}
// Complete a handshake in order to prime the crypto config for 0-RTT.
CompleteCryptoHandshake();
// Now create a second session using the same crypto config.
Initialize();
// Starting the handshake should move immediately to encryption
// established and will allow streams to be created.
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream != nullptr);
EXPECT_FALSE(QuicUtils::IsCryptoStreamId(connection_->transport_version(),
stream->id()));
// Process an "inchoate" REJ from the server which will cause
// an inchoate CHLO to be sent and will leave the encryption level
// at NONE.
CryptoHandshakeMessage rej;
crypto_test_utils::FillInDummyReject(&rej);
EXPECT_TRUE(session_->IsEncryptionEstablished());
crypto_test_utils::SendHandshakeMessageToStream(
session_->GetMutableCryptoStream(), rej, Perspective::IS_CLIENT);
EXPECT_FALSE(session_->IsEncryptionEstablished());
EXPECT_EQ(ENCRYPTION_INITIAL,
QuicPacketCreatorPeer::GetEncryptionLevel(
QuicConnectionPeer::GetPacketCreator(connection_)));
// Verify that no new streams may be created.
EXPECT_TRUE(session_->CreateOutgoingBidirectionalStream() == nullptr);
// Verify that no data may be send on existing streams.
char data[] = "hello world";
QuicConsumedData consumed =
session_->WritevData(stream->id(), ABSL_ARRAYSIZE(data), 0, NO_FIN,
NOT_RETRANSMISSION, ENCRYPTION_INITIAL);
EXPECT_EQ(0u, consumed.bytes_consumed);
EXPECT_FALSE(consumed.fin_consumed);
}
TEST_P(QuicSpdyClientSessionTest, MaxNumStreamsWithNoFinOrRst) {
uint32_t kServerMaxIncomingStreams = 1;
CompleteCryptoHandshake(kServerMaxIncomingStreams);
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream);
EXPECT_FALSE(session_->CreateOutgoingBidirectionalStream());
// Close the stream, but without having received a FIN or a RST_STREAM
// or MAX_STREAMS (IETF QUIC) and check that a new one can not be created.
session_->ResetStream(stream->id(), QUIC_STREAM_CANCELLED);
EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
stream = session_->CreateOutgoingBidirectionalStream();
EXPECT_FALSE(stream);
}
TEST_P(QuicSpdyClientSessionTest, MaxNumStreamsWithRst) {
uint32_t kServerMaxIncomingStreams = 1;
CompleteCryptoHandshake(kServerMaxIncomingStreams);
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_NE(nullptr, stream);
EXPECT_EQ(nullptr, session_->CreateOutgoingBidirectionalStream());
// Close the stream and receive an RST frame to remove the unfinished stream
session_->ResetStream(stream->id(), QUIC_STREAM_CANCELLED);
session_->OnRstStream(QuicRstStreamFrame(kInvalidControlFrameId, stream->id(),
QUIC_RST_ACKNOWLEDGEMENT, 0));
// Check that a new one can be created.
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
// In IETF QUIC the stream limit increases only if we get a MAX_STREAMS
// frame; pretend we got one.
QuicMaxStreamsFrame frame(0, 2,
/*unidirectional=*/false);
session_->OnMaxStreamsFrame(frame);
}
stream = session_->CreateOutgoingBidirectionalStream();
EXPECT_NE(nullptr, stream);
if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
// Ensure that we have 2 total streams, 1 open and 1 closed.
QuicStreamCount expected_stream_count = 2;
EXPECT_EQ(expected_stream_count,
QuicSessionPeer::ietf_bidirectional_stream_id_manager(&*session_)
->outgoing_stream_count());
}
}
TEST_P(QuicSpdyClientSessionTest, ResetAndTrailers) {
// Tests the situation in which the client sends a RST at the same time that
// the server sends trailing headers (trailers). Receipt of the trailers by
// the client should result in all outstanding stream state being tidied up
// (including flow control, and number of available outgoing streams).
uint32_t kServerMaxIncomingStreams = 1;
CompleteCryptoHandshake(kServerMaxIncomingStreams);
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_NE(nullptr, stream);
if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
// For IETF QUIC, trying to open a stream and failing due to lack
// of stream ids will result in a STREAMS_BLOCKED. Make
// sure we get one. Also clear out the frame because if it's
// left sitting, the later SendRstStream will not actually
// transmit the RST_STREAM because the connection will be in write-blocked
// state. This means that the SendControlFrame that is expected w.r.t. the
// RST_STREAM, below, will not be satisfied.
EXPECT_CALL(*connection_, SendControlFrame(_))
.WillOnce(Invoke(
this, &QuicSpdyClientSessionTest::ClearStreamsBlockedControlFrame));
}
EXPECT_EQ(nullptr, session_->CreateOutgoingBidirectionalStream());
QuicStreamId stream_id = stream->id();
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(AtLeast(1))
.WillRepeatedly(Invoke(&ClearControlFrame));
EXPECT_CALL(*connection_, OnStreamReset(_, _)).Times(1);
session_->ResetStream(stream_id, QUIC_STREAM_PEER_GOING_AWAY);
// A new stream cannot be created as the reset stream still counts as an open
// outgoing stream until closed by the server.
EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
stream = session_->CreateOutgoingBidirectionalStream();
EXPECT_EQ(nullptr, stream);
// The stream receives trailers with final byte offset: this is one of three
// ways that a peer can signal the end of a stream (the others being RST,
// stream data + FIN).
QuicHeaderList trailers;
trailers.OnHeaderBlockStart();
trailers.OnHeader(kFinalOffsetHeaderKey, "0");
trailers.OnHeaderBlockEnd(0, 0);
session_->OnStreamHeaderList(stream_id, /*fin=*/false, 0, trailers);
// The stream is now complete from the client's perspective, and it should
// be able to create a new outgoing stream.
EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
QuicMaxStreamsFrame frame(0, 2,
/*unidirectional=*/false);
session_->OnMaxStreamsFrame(frame);
}
stream = session_->CreateOutgoingBidirectionalStream();
EXPECT_NE(nullptr, stream);
if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
// Ensure that we have 2 open streams.
QuicStreamCount expected_stream_count = 2;
EXPECT_EQ(expected_stream_count,
QuicSessionPeer::ietf_bidirectional_stream_id_manager(&*session_)
->outgoing_stream_count());
}
}
TEST_P(QuicSpdyClientSessionTest, ReceivedMalformedTrailersAfterSendingRst) {
// Tests the situation where the client has sent a RST to the server, and has
// received trailing headers with a malformed final byte offset value.
CompleteCryptoHandshake();
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_NE(nullptr, stream);
// Send the RST, which results in the stream being closed locally (but some
// state remains while the client waits for a response from the server).
QuicStreamId stream_id = stream->id();
EXPECT_CALL(*connection_, SendControlFrame(_))
.Times(AtLeast(1))
.WillRepeatedly(Invoke(&ClearControlFrame));
EXPECT_CALL(*connection_, OnStreamReset(_, _)).Times(1);
session_->ResetStream(stream_id, QUIC_STREAM_PEER_GOING_AWAY);
// The stream receives trailers with final byte offset, but the header value
// is non-numeric and should be treated as malformed.
QuicHeaderList trailers;
trailers.OnHeaderBlockStart();
trailers.OnHeader(kFinalOffsetHeaderKey, "invalid non-numeric value");
trailers.OnHeaderBlockEnd(0, 0);
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(1);
session_->OnStreamHeaderList(stream_id, /*fin=*/false, 0, trailers);
}
TEST_P(QuicSpdyClientSessionTest, OnStreamHeaderListWithStaticStream) {
// Test situation where OnStreamHeaderList is called by stream with static id.
CompleteCryptoHandshake();
QuicHeaderList trailers;
trailers.OnHeaderBlockStart();
trailers.OnHeader(kFinalOffsetHeaderKey, "0");
trailers.OnHeaderBlockEnd(0, 0);
// Initialize H/3 control stream.
QuicStreamId id;
if (VersionUsesHttp3(connection_->transport_version())) {
id = GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 3);
char type[] = {0x00};
QuicStreamFrame data1(id, false, 0, absl::string_view(type, 1));
session_->OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
}
EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
"stream is static", _))
.Times(1);
session_->OnStreamHeaderList(id,
/*fin=*/false, 0, trailers);
}
TEST_P(QuicSpdyClientSessionTest, OnPromiseHeaderListWithStaticStream) {
// Test situation where OnPromiseHeaderList is called by stream with static
// id.
CompleteCryptoHandshake();
QuicHeaderList trailers;
trailers.OnHeaderBlockStart();
trailers.OnHeader(kFinalOffsetHeaderKey, "0");
trailers.OnHeaderBlockEnd(0, 0);
// Initialize H/3 control stream.
QuicStreamId id;
if (VersionUsesHttp3(connection_->transport_version())) {
id = GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 3);
char type[] = {0x00};
QuicStreamFrame data1(id, false, 0, absl::string_view(type, 1));
session_->OnStreamFrame(data1);
} else {
id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
}
EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
"stream is static", _))
.Times(1);
session_->OnPromiseHeaderList(id, promised_stream_id_, 0, trailers);
}
TEST_P(QuicSpdyClientSessionTest, GoAwayReceived) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
return;
}
CompleteCryptoHandshake();
// After receiving a GoAway, I should no longer be able to create outgoing
// streams.
session_->connection()->OnGoAwayFrame(QuicGoAwayFrame(
kInvalidControlFrameId, QUIC_PEER_GOING_AWAY, 1u, "Going away."));
EXPECT_EQ(nullptr, session_->CreateOutgoingBidirectionalStream());
}
static bool CheckForDecryptionError(QuicFramer* framer) {
return framer->error() == QUIC_DECRYPTION_FAILURE;
}
// Various sorts of invalid packets that should not cause a connection
// to be closed.
TEST_P(QuicSpdyClientSessionTest, InvalidPacketReceived) {
QuicSocketAddress server_address(TestPeerIPAddress(), kTestPort);
QuicSocketAddress client_address(TestPeerIPAddress(), kTestPort);
EXPECT_CALL(*connection_, ProcessUdpPacket(server_address, client_address, _))
.WillRepeatedly(Invoke(static_cast<MockQuicConnection*>(connection_),
&MockQuicConnection::ReallyProcessUdpPacket));
EXPECT_CALL(*connection_, OnCanWrite()).Times(AnyNumber());
EXPECT_CALL(*connection_, OnError(_)).Times(1);
// Verify that empty packets don't close the connection.
QuicReceivedPacket zero_length_packet(nullptr, 0, QuicTime::Zero(), false);
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
session_->ProcessUdpPacket(client_address, server_address,
zero_length_packet);
// Verifiy that small, invalid packets don't close the connection.
char buf[2] = {0x00, 0x01};
QuicConnectionId connection_id = session_->connection()->connection_id();
QuicReceivedPacket valid_packet(buf, 2, QuicTime::Zero(), false);
// Close connection shouldn't be called.
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
EXPECT_CALL(*connection_, OnError(_)).Times(AtMost(1));
session_->ProcessUdpPacket(client_address, server_address, valid_packet);
// Verify that a non-decryptable packet doesn't close the connection.
QuicFramerPeer::SetLastSerializedServerConnectionId(
QuicConnectionPeer::GetFramer(connection_), connection_id);
ParsedQuicVersionVector versions = SupportedVersions(GetParam());
QuicConnectionId destination_connection_id = EmptyQuicConnectionId();
QuicConnectionId source_connection_id = connection_id;
std::unique_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
destination_connection_id, source_connection_id, false, false, 100,
"data", true, CONNECTION_ID_ABSENT, CONNECTION_ID_ABSENT,
PACKET_4BYTE_PACKET_NUMBER, &versions, Perspective::IS_SERVER));
std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*packet, QuicTime::Zero()));
// Change the last byte of the encrypted data.
*(const_cast<char*>(received->data() + received->length() - 1)) += 1;
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
EXPECT_CALL(*connection_, OnError(Truly(CheckForDecryptionError))).Times(1);
session_->ProcessUdpPacket(client_address, server_address, *received);
}
// A packet with invalid framing should cause a connection to be closed.
TEST_P(QuicSpdyClientSessionTest, InvalidFramedPacketReceived) {
const ParsedQuicVersion version = GetParam();
QuicSocketAddress server_address(TestPeerIPAddress(), kTestPort);
QuicSocketAddress client_address(TestPeerIPAddress(), kTestPort);
if (version.KnowsWhichDecrypterToUse()) {
connection_->InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
} else {
connection_->SetDecrypter(
ENCRYPTION_FORWARD_SECURE,
std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
}
EXPECT_CALL(*connection_, ProcessUdpPacket(server_address, client_address, _))
.WillRepeatedly(Invoke(static_cast<MockQuicConnection*>(connection_),
&MockQuicConnection::ReallyProcessUdpPacket));
EXPECT_CALL(*connection_, OnError(_)).Times(1);
// Verify that a decryptable packet with bad frames does close the connection.
QuicConnectionId destination_connection_id =
session_->connection()->connection_id();
QuicConnectionId source_connection_id = EmptyQuicConnectionId();
QuicFramerPeer::SetLastSerializedServerConnectionId(
QuicConnectionPeer::GetFramer(connection_), destination_connection_id);
bool version_flag = false;
QuicConnectionIdIncluded scid_included = CONNECTION_ID_ABSENT;
if (version.HasIetfInvariantHeader()) {
version_flag = true;
source_connection_id = destination_connection_id;
scid_included = CONNECTION_ID_PRESENT;
}
std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
destination_connection_id, source_connection_id, version_flag, false, 100,
"data", CONNECTION_ID_ABSENT, scid_included, PACKET_4BYTE_PACKET_NUMBER,
version, Perspective::IS_SERVER));
std::unique_ptr<QuicReceivedPacket> received(
ConstructReceivedPacket(*packet, QuicTime::Zero()));
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(1);
session_->ProcessUdpPacket(client_address, server_address, *received);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseOnPromiseHeaders) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
return;
}
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
session_->CreateOutgoingBidirectionalStream());
EXPECT_CALL(*stream, OnPromiseHeaderList(_, _, _));
session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
QuicHeaderList());
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseStreamIdTooHigh) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
return;
}
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
QuicStreamId stream_id =
QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
QuicSessionPeer::ActivateStream(
session_.get(), std::make_unique<QuicSpdyClientStream>(
stream_id, session_.get(), BIDIRECTIONAL));
QuicHeaderList headers;
headers.OnHeaderBlockStart();
headers.OnHeader(":path", "/bar");
headers.OnHeader(":authority", "www.google.com");
headers.OnHeader(":method", "GET");
headers.OnHeader(":scheme", "https");
headers.OnHeaderBlockEnd(0, 0);
const QuicStreamId promise_id = GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 11);
session_->OnPromiseHeaderList(stream_id, promise_id, 0, headers);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseOnPromiseHeadersAlreadyClosed) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
QuicHeaderList());
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseOutOfOrder) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
return;
}
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
session_->CreateOutgoingBidirectionalStream());
EXPECT_CALL(*stream, OnPromiseHeaderList(promised_stream_id_, _, _));
session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
QuicHeaderList());
associated_stream_id_ +=
QuicUtils::StreamIdDelta(connection_->transport_version());
if (!VersionUsesHttp3(session_->transport_version())) {
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
"Received push stream id lesser or equal to the"
" last accepted before",
_));
}
session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
QuicHeaderList());
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseOutgoingStreamId) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
session_->CreateOutgoingBidirectionalStream());
// Promise an illegal (outgoing) stream id.
promised_stream_id_ = GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0);
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
"Received push stream id for outgoing stream.", _));
session_->OnPromiseHeaderList(stream->id(), promised_stream_id_, 0,
QuicHeaderList());
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseHandlePromise) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
EXPECT_TRUE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_NE(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseAlreadyClosed) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
session_->GetOrCreateStream(promised_stream_id_);
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
SpdyHeaderBlock promise_headers;
EXPECT_FALSE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, promise_headers));
// Verify that the promise was not created.
EXPECT_EQ(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseDuplicateUrl) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
EXPECT_TRUE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_NE(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
promised_stream_id_ +=
QuicUtils::StreamIdDelta(connection_->transport_version());
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_DUPLICATE_PROMISE_URL));
EXPECT_FALSE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
// Verify that the promise was not created.
EXPECT_EQ(session_->GetPromisedById(promised_stream_id_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, ReceivingPromiseEnhanceYourCalm) {
CompleteCryptoHandshake();
for (size_t i = 0u; i < session_->get_max_promises(); i++) {
push_promise_[":path"] = absl::StrCat("/bar", i);
QuicStreamId id =
promised_stream_id_ +
i * QuicUtils::StreamIdDelta(connection_->transport_version());
EXPECT_TRUE(
session_->HandlePromised(associated_stream_id_, id, push_promise_));
// Verify that the promise is in the unclaimed streams map.
std::string promise_url(
SpdyServerPushUtils::GetPromisedUrlFromHeaders(push_promise_));
EXPECT_NE(session_->GetPromisedByUrl(promise_url), nullptr);
EXPECT_NE(session_->GetPromisedById(id), nullptr);
}
// One more promise, this should be refused.
int i = session_->get_max_promises();
push_promise_[":path"] = absl::StrCat("/bar", i);
QuicStreamId id =
promised_stream_id_ +
i * QuicUtils::StreamIdDelta(connection_->transport_version());
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_, OnStreamReset(id, QUIC_REFUSED_STREAM));
EXPECT_FALSE(
session_->HandlePromised(associated_stream_id_, id, push_promise_));
// Verify that the promise was not created.
std::string promise_url(
SpdyServerPushUtils::GetPromisedUrlFromHeaders(push_promise_));
EXPECT_EQ(session_->GetPromisedById(id), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, IsClosedTrueAfterResetPromisedAlreadyOpen) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->GetOrCreateStream(promised_stream_id_);
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
EXPECT_TRUE(session_->IsClosedStream(promised_stream_id_));
}
TEST_P(QuicSpdyClientSessionTest, IsClosedTrueAfterResetPromisedNonexistant) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
EXPECT_TRUE(session_->IsClosedStream(promised_stream_id_));
}
TEST_P(QuicSpdyClientSessionTest, OnInitialHeadersCompleteIsPush) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->GetOrCreateStream(promised_stream_id_);
EXPECT_TRUE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_NE(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_NE(session_->GetPromisedStream(promised_stream_id_), nullptr);
EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
session_->OnInitialHeadersComplete(promised_stream_id_, SpdyHeaderBlock());
}
TEST_P(QuicSpdyClientSessionTest, OnInitialHeadersCompleteIsNotPush) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
session_->OnInitialHeadersComplete(promised_stream_id_, SpdyHeaderBlock());
}
TEST_P(QuicSpdyClientSessionTest, DeletePromised) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->GetOrCreateStream(promised_stream_id_);
EXPECT_TRUE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
QuicClientPromisedInfo* promised =
session_->GetPromisedById(promised_stream_id_);
EXPECT_NE(promised, nullptr);
EXPECT_NE(session_->GetPromisedStream(promised_stream_id_), nullptr);
EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
session_->DeletePromised(promised);
EXPECT_EQ(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, ResetPromised) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->GetOrCreateStream(promised_stream_id_);
EXPECT_TRUE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_STREAM_PEER_GOING_AWAY));
session_->ResetStream(promised_stream_id_, QUIC_STREAM_PEER_GOING_AWAY);
QuicClientPromisedInfo* promised =
session_->GetPromisedById(promised_stream_id_);
EXPECT_NE(promised, nullptr);
EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
EXPECT_EQ(session_->GetPromisedStream(promised_stream_id_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseInvalidMethod) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_INVALID_PROMISE_METHOD));
push_promise_[":method"] = "POST";
EXPECT_FALSE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_EQ(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest, PushPromiseInvalidHost) {
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
session_->CreateOutgoingBidirectionalStream();
EXPECT_CALL(*connection_, SendControlFrame(_));
EXPECT_CALL(*connection_,
OnStreamReset(promised_stream_id_, QUIC_INVALID_PROMISE_URL));
push_promise_[":authority"] = "";
EXPECT_FALSE(session_->HandlePromised(associated_stream_id_,
promised_stream_id_, push_promise_));
EXPECT_EQ(session_->GetPromisedById(promised_stream_id_), nullptr);
EXPECT_EQ(session_->GetPromisedByUrl(promise_url_), nullptr);
}
TEST_P(QuicSpdyClientSessionTest,
TryToCreateServerInitiatedBidirectionalStream) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_SERVER_INITIATED_BIDIRECTIONAL_STREAM, _, _));
} else {
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
}
session_->GetOrCreateStream(GetNthServerInitiatedBidirectionalStreamId(
connection_->transport_version(), 0));
}
TEST_P(QuicSpdyClientSessionTest, TooManyPushPromises) {
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
return;
}
// Initialize crypto before the client session will create a stream.
CompleteCryptoHandshake();
QuicStreamId stream_id =
QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
QuicSessionPeer::ActivateStream(
session_.get(), std::make_unique<QuicSpdyClientStream>(
stream_id, session_.get(), BIDIRECTIONAL));
EXPECT_CALL(*connection_, OnStreamReset(_, QUIC_REFUSED_STREAM));
for (size_t promise_count = 0; promise_count <= session_->get_max_promises();
promise_count++) {
auto promise_id = GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), promise_count);
auto headers = QuicHeaderList();
headers.OnHeaderBlockStart();
headers.OnHeader(":path", absl::StrCat("/", promise_count));
headers.OnHeader(":authority", "www.google.com");
headers.OnHeader(":method", "GET");
headers.OnHeader(":scheme", "https");
headers.OnHeaderBlockEnd(0, 0);
session_->OnPromiseHeaderList(stream_id, promise_id, 0, headers);
}
}
// Test that upon receiving HTTP/3 SETTINGS, the settings are serialized and
// stored into client session cache.
TEST_P(QuicSpdyClientSessionTest, OnSettingsFrame) {
// This feature is HTTP/3 only
if (!VersionUsesHttp3(session_->transport_version())) {
return;
}
CompleteCryptoHandshake();
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 2;
settings.values[SETTINGS_MAX_FIELD_SECTION_SIZE] = 5;
settings.values[256] = 4; // unknown setting
char application_state[] = {// type (SETTINGS)
0x04,
// length
0x07,
// identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
0x01,
// content
0x02,
// identifier (SETTINGS_MAX_FIELD_SECTION_SIZE)
0x06,
// content
0x05,
// identifier (256 in variable length integer)
0x40 + 0x01, 0x00,
// content
0x04};
ApplicationState expected(std::begin(application_state),
std::end(application_state));
session_->OnSettingsFrame(settings);
EXPECT_EQ(expected, *client_session_cache_
->Lookup(QuicServerId(kServerHostname, kPort, false),
session_->GetClock()->WallNow(), nullptr)
->application_state);
}
TEST_P(QuicSpdyClientSessionTest, IetfZeroRttSetup) {
// This feature is TLS-only.
if (session_->version().UsesQuicCrypto()) {
return;
}
CompleteFirstConnection();
CreateConnection();
// Session configs should be in initial state.
if (session_->version().UsesHttp3()) {
EXPECT_EQ(0u, session_->flow_controller()->send_window_offset());
EXPECT_EQ(std::numeric_limits<size_t>::max(),
session_->max_outbound_header_list_size());
} else {
EXPECT_EQ(kMinimumFlowControlSendWindow,
session_->flow_controller()->send_window_offset());
}
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
EXPECT_EQ(ENCRYPTION_ZERO_RTT, session_->connection()->encryption_level());
// The client session should have a basic setup ready before the handshake
// succeeds.
EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
session_->flow_controller()->send_window_offset());
if (session_->version().UsesHttp3()) {
auto* id_manager = QuicSessionPeer::ietf_streamid_manager(session_.get());
EXPECT_EQ(kDefaultMaxStreamsPerConnection,
id_manager->max_outgoing_bidirectional_streams());
EXPECT_EQ(
kDefaultMaxStreamsPerConnection + kHttp3StaticUnidirectionalStreamCount,
id_manager->max_outgoing_unidirectional_streams());
auto* control_stream =
QuicSpdySessionPeer::GetSendControlStream(session_.get());
EXPECT_EQ(kInitialStreamFlowControlWindowForTest,
QuicStreamPeer::SendWindowOffset(control_stream));
EXPECT_EQ(5u, session_->max_outbound_header_list_size());
} else {
auto* id_manager = QuicSessionPeer::GetStreamIdManager(session_.get());
EXPECT_EQ(kDefaultMaxStreamsPerConnection,
id_manager->max_open_outgoing_streams());
}
// Complete the handshake with a different config.
QuicConfig config = DefaultQuicConfig();
config.SetInitialMaxStreamDataBytesUnidirectionalToSend(
kInitialStreamFlowControlWindowForTest + 1);
config.SetInitialSessionFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest + 1);
config.SetMaxBidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection + 1);
config.SetMaxUnidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection + 1);
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
EXPECT_TRUE(session_->GetCryptoStream()->IsResumption());
EXPECT_EQ(kInitialSessionFlowControlWindowForTest + 1,
session_->flow_controller()->send_window_offset());
if (session_->version().UsesHttp3()) {
auto* id_manager = QuicSessionPeer::ietf_streamid_manager(session_.get());
auto* control_stream =
QuicSpdySessionPeer::GetSendControlStream(session_.get());
EXPECT_EQ(kDefaultMaxStreamsPerConnection + 1,
id_manager->max_outgoing_bidirectional_streams());
EXPECT_EQ(kDefaultMaxStreamsPerConnection +
kHttp3StaticUnidirectionalStreamCount + 1,
id_manager->max_outgoing_unidirectional_streams());
EXPECT_EQ(kInitialStreamFlowControlWindowForTest + 1,
QuicStreamPeer::SendWindowOffset(control_stream));
} else {
auto* id_manager = QuicSessionPeer::GetStreamIdManager(session_.get());
EXPECT_EQ(kDefaultMaxStreamsPerConnection + 1,
id_manager->max_open_outgoing_streams());
}
EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
// Let the session receive a new SETTINGS frame to complete the second
// connection.
if (session_->version().UsesHttp3()) {
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 2;
settings.values[SETTINGS_MAX_FIELD_SECTION_SIZE] = 5;
settings.values[256] = 4; // unknown setting
session_->OnSettingsFrame(settings);
}
}
// Regression test for b/159168475
TEST_P(QuicSpdyClientSessionTest, RetransmitDataOnZeroRttReject) {
// This feature is TLS-only.
if (session_->version().UsesQuicCrypto()) {
return;
}
CompleteFirstConnection();
// Create a second connection, but disable 0-RTT on the server.
CreateConnection();
ON_CALL(*connection_, OnCanWrite())
.WillByDefault(
testing::Invoke(connection_, &MockQuicConnection::ReallyOnCanWrite));
EXPECT_CALL(*connection_, OnCanWrite()).Times(0);
QuicConfig config = DefaultQuicConfig();
config.SetMaxUnidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
config.SetMaxBidirectionalStreamsToSend(kDefaultMaxStreamsPerConnection);
SSL_CTX_set_early_data_enabled(server_crypto_config_->ssl_ctx(), false);
// Packets will be written: CHLO, HTTP/3 SETTINGS (H/3 only), and request
// data.
EXPECT_CALL(*connection_,
OnPacketSent(ENCRYPTION_INITIAL, NOT_RETRANSMISSION));
EXPECT_CALL(*connection_,
OnPacketSent(ENCRYPTION_ZERO_RTT, NOT_RETRANSMISSION))
.Times(session_->version().UsesHttp3() ? 2 : 1);
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
EXPECT_EQ(ENCRYPTION_ZERO_RTT, session_->connection()->encryption_level());
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream);
stream->WriteOrBufferData("hello", true, nullptr);
// When handshake is done, the client sends 2 packet: HANDSHAKE FINISHED, and
// coalesced retransmission of HTTP/3 SETTINGS and request data.
EXPECT_CALL(*connection_,
OnPacketSent(ENCRYPTION_HANDSHAKE, NOT_RETRANSMISSION));
// TODO(b/158027651): change transmission type to ALL_ZERO_RTT_RETRANSMISSION.
EXPECT_CALL(*connection_,
OnPacketSent(ENCRYPTION_FORWARD_SECURE, LOSS_RETRANSMISSION));
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
EXPECT_TRUE(session_->GetCryptoStream()->IsResumption());
}
// When IETF QUIC 0-RTT is rejected, a server-sent fresh transport params is
// available. If the new transport params reduces stream/flow control limit to
// lower than what the client has already used, connection will be closed.
TEST_P(QuicSpdyClientSessionTest, ZeroRttRejectReducesStreamLimitTooMuch) {
// This feature is TLS-only.
if (session_->version().UsesQuicCrypto()) {
return;
}
CompleteFirstConnection();
// Create a second connection, but disable 0-RTT on the server.
CreateConnection();
QuicConfig config = DefaultQuicConfig();
// Server doesn't allow any bidirectional streams.
config.SetMaxBidirectionalStreamsToSend(0);
SSL_CTX_set_early_data_enabled(server_crypto_config_->ssl_ctx(), false);
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream);
if (session_->version().UsesHttp3()) {
EXPECT_CALL(
*connection_,
CloseConnection(
QUIC_ZERO_RTT_UNRETRANSMITTABLE,
"Server rejected 0-RTT, aborting because new bidirectional initial "
"stream limit 0 is less than current open streams: 1",
_))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
} else {
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_INTERNAL_ERROR,
"Server rejected 0-RTT, aborting because new stream "
"limit 0 is less than current open streams: 1",
_))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
}
EXPECT_CALL(*connection_, CloseConnection(QUIC_HANDSHAKE_FAILED, _, _));
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
}
TEST_P(QuicSpdyClientSessionTest,
ZeroRttRejectReducesStreamFlowControlTooMuch) {
// This feature is TLS-only.
if (session_->version().UsesQuicCrypto()) {
return;
}
CompleteFirstConnection();
// Create a second connection, but disable 0-RTT on the server.
CreateConnection();
QuicConfig config = DefaultQuicConfig();
// Server doesn't allow any outgoing streams.
config.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(2);
config.SetInitialMaxStreamDataBytesUnidirectionalToSend(1);
SSL_CTX_set_early_data_enabled(server_crypto_config_->ssl_ctx(), false);
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream);
// Let the stream write more than 1 byte of data.
stream->WriteOrBufferData("hello", true, nullptr);
if (session_->version().UsesHttp3()) {
// Both control stream and the request stream will report errors.
// Open question: should both streams be closed with the same error code?
EXPECT_CALL(*connection_, CloseConnection(_, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
EXPECT_CALL(*connection_,
CloseConnection(QUIC_ZERO_RTT_UNRETRANSMITTABLE, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection))
.RetiresOnSaturation();
} else {
EXPECT_CALL(*connection_,
CloseConnection(
QUIC_ZERO_RTT_UNRETRANSMITTABLE,
"Server rejected 0-RTT, aborting because new stream max "
"data 2 for stream 3 is less than currently used: 5",
_))
.Times(1)
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
}
EXPECT_CALL(*connection_, CloseConnection(QUIC_HANDSHAKE_FAILED, _, _));
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
}
TEST_P(QuicSpdyClientSessionTest,
ZeroRttRejectReducesSessionFlowControlTooMuch) {
// This feature is TLS-only.
if (session_->version().UsesQuicCrypto()) {
return;
}
CompleteFirstConnection();
// Create a second connection, but disable 0-RTT on the server.
CreateConnection();
QuicConfig config = DefaultQuicConfig();
// Server doesn't allow minimum data in session.
config.SetInitialSessionFlowControlWindowToSend(
kMinimumFlowControlSendWindow);
SSL_CTX_set_early_data_enabled(server_crypto_config_->ssl_ctx(), false);
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
ASSERT_TRUE(stream);
std::string data_to_send(kMinimumFlowControlSendWindow + 1, 'x');
// Let the stream write some data.
stream->WriteOrBufferData(data_to_send, true, nullptr);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_ZERO_RTT_UNRETRANSMITTABLE, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
EXPECT_CALL(*connection_, CloseConnection(QUIC_HANDSHAKE_FAILED, _, _));
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
}
TEST_P(QuicSpdyClientSessionTest, BadSettingsInZeroRttResumption) {
if (!session_->version().UsesHttp3()) {
return;
}
CompleteFirstConnection();
CreateConnection();
CompleteCryptoHandshake();
EXPECT_TRUE(session_->GetCryptoStream()->EarlyDataAccepted());
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_ZERO_RTT_RESUMPTION_SETTINGS_MISMATCH, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
// Let the session receive a different SETTINGS frame.
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 1;
settings.values[SETTINGS_MAX_FIELD_SECTION_SIZE] = 5;
settings.values[256] = 4; // unknown setting
session_->OnSettingsFrame(settings);
}
TEST_P(QuicSpdyClientSessionTest, BadSettingsInZeroRttRejection) {
if (!session_->version().UsesHttp3()) {
return;
}
CompleteFirstConnection();
CreateConnection();
SSL_CTX_set_early_data_enabled(server_crypto_config_->ssl_ctx(), false);
session_->CryptoConnect();
EXPECT_TRUE(session_->IsEncryptionEstablished());
QuicConfig config = DefaultQuicConfig();
crypto_test_utils::HandshakeWithFakeServer(
&config, server_crypto_config_.get(), &helper_, &alarm_factory_,
connection_, crypto_stream_, AlpnForVersion(connection_->version()));
EXPECT_FALSE(session_->GetCryptoStream()->EarlyDataAccepted());
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_ZERO_RTT_REJECTION_SETTINGS_MISMATCH, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
// Let the session receive a different SETTINGS frame.
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 2;
// setting on SETTINGS_MAX_FIELD_SECTION_SIZE is reduced.
settings.values[SETTINGS_MAX_FIELD_SECTION_SIZE] = 4;
settings.values[256] = 4; // unknown setting
session_->OnSettingsFrame(settings);
}
TEST_P(QuicSpdyClientSessionTest, ServerAcceptsZeroRttButOmitSetting) {
if (!session_->version().UsesHttp3()) {
return;
}
CompleteFirstConnection();
CreateConnection();
CompleteCryptoHandshake();
EXPECT_TRUE(session_->GetMutableCryptoStream()->EarlyDataAccepted());
EXPECT_CALL(
*connection_,
CloseConnection(QUIC_HTTP_ZERO_RTT_RESUMPTION_SETTINGS_MISMATCH, _, _))
.WillOnce(testing::Invoke(connection_,
&MockQuicConnection::ReallyCloseConnection));
// Let the session receive a different SETTINGS frame.
SettingsFrame settings;
settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] = 1;
// Intentionally omit SETTINGS_MAX_FIELD_SECTION_SIZE which was previously
// sent with a non-zero value.
settings.values[256] = 4; // unknown setting
session_->OnSettingsFrame(settings);
}
} // namespace
} // namespace test
} // namespace quic