Use the CHLO packet size, not message size when determining how large a REJ can be. Protected by --…

net/quic/core/quic_crypto_server_stream.cc

 // 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 "net/quic/core/quic_crypto_server_stream.h"
 
 #include <memory>
 
 #include "base/base64.h"
 #include "crypto/secure_hash.h"
@@ skipping 62 matching lines @@
     : QuicCryptoServerStreamBase(session),
       crypto_config_(crypto_config),
       compressed_certs_cache_(compressed_certs_cache),
       validate_client_hello_cb_(nullptr),
       num_handshake_messages_(0),
       num_handshake_messages_with_server_nonces_(0),
       send_server_config_update_cb_(nullptr),
       num_server_config_update_messages_sent_(0),
       use_stateless_rejects_if_peer_supported_(
           use_stateless_rejects_if_peer_supported),
-      peer_supports_stateless_rejects_(false) {
+      peer_supports_stateless_rejects_(false),
+      chlo_packet_size_(0) {
   DCHECK_EQ(Perspective::IS_SERVER, session->connection()->perspective());
 }
 
 QuicCryptoServerStream::~QuicCryptoServerStream() {
   CancelOutstandingCallbacks();
 }
 
 void QuicCryptoServerStream::CancelOutstandingCallbacks() {
   // Detach from the validation callback.  Calling this multiple times is safe.
   if (validate_client_hello_cb_ != nullptr) {
     validate_client_hello_cb_->Cancel();
     validate_client_hello_cb_ = nullptr;
   }
   if (send_server_config_update_cb_ != nullptr) {
     send_server_config_update_cb_->Cancel();
     send_server_config_update_cb_ = nullptr;
   }
 }
 
 void QuicCryptoServerStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
   QuicCryptoServerStreamBase::OnHandshakeMessage(message);
   ++num_handshake_messages_;
+  chlo_packet_size_ = session()->connection()->GetCurrentPacket().length();
 
   bool require_kfixd = !FLAGS_quic_deprecate_kfixd;
 
   if (require_kfixd && !HasFixedTag(message)) {
     CloseConnectionWithDetails(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
                                "Missing kFIXD");
     return;
   }
 
   // Do not process handshake messages after the handshake is confirmed.
@@ skipping 315 matching lines @@
       use_stateless_rejects_in_crypto_config
           ? GenerateConnectionIdForReject(connection->connection_id())
           : 0;
   return crypto_config_->ProcessClientHello(
       result, /*reject_only=*/false, connection->connection_id(),
       connection->self_address().address(), connection->peer_address(),
       version(), connection->supported_versions(),
       use_stateless_rejects_in_crypto_config, server_designated_connection_id,
       connection->clock(), connection->random_generator(),
       compressed_certs_cache_, &crypto_negotiated_params_, &crypto_proof_,
-      reply, out_diversification_nonce, error_details);
+      QuicCryptoStream::CryptoMessageFramingOverhead(version()),
+      chlo_packet_size_, reply, out_diversification_nonce, error_details);
 }
 
 void QuicCryptoServerStream::OverrideQuicConfigDefaults(QuicConfig* config) {}
 
 QuicCryptoServerStream::ValidateCallback::ValidateCallback(
     QuicCryptoServerStream* parent)
     : parent_(parent) {}
 
 void QuicCryptoServerStream::ValidateCallback::Cancel() {
   parent_ = nullptr;
@@ skipping 12 matching lines @@
 QuicConnectionId QuicCryptoServerStream::GenerateConnectionIdForReject(
     QuicConnectionId connection_id) {
   // TODO(rch): Remove this method when
   // reloadable_flag_quic_dispatcher_creates_id2 is removed.
   QuicServerSessionBase* session_base =
       static_cast<QuicServerSessionBase*>(session());
   return session_base->GenerateConnectionIdForReject(connection_id);
 }
 
 }  // namespace net