QUIC: support diversified keys with version 33.

net/quic/quic_connection_test.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/quic_connection.h"
 
 #include <errno.h>
 #include <memory>
 #include <ostream>
 #include <utility>
@@ skipping 123 matching lines @@
 // have the same value and then removes them.
 class TaggingDecrypter : public QuicDecrypter {
  public:
   ~TaggingDecrypter() override {}
 
   // QuicDecrypter interface
   bool SetKey(StringPiece key) override { return true; }
 
   bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 
+  bool SetPreliminaryKey(StringPiece key) override {
+    QUIC_BUG << "should not be called";
+    return false;
+  }
+
+  bool SetDiversificationNonce(DiversificationNonce key) override {
+    return true;
+  }
+
   bool DecryptPacket(QuicPathId path_id,
                      QuicPacketNumber packet_number,
                      StringPiece associated_data,
                      StringPiece ciphertext,
                      char* output,
                      size_t* output_length,
                      size_t max_output_length) override {
     if (ciphertext.size() < kTagSize) {
       return false;
     }
@@ skipping 3269 matching lines @@
                          kTestEntropyHash, HAS_RETRANSMITTABLE_DATA, false,
                          false);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
   // All packets carry version info till version is negotiated.
   size_t payload_length;
   size_t length = GetPacketLengthForOneStream(
       connection_.version(), kIncludeVersion, !kIncludePathId,
-      PACKET_8BYTE_CONNECTION_ID, PACKET_1BYTE_PACKET_NUMBER, &payload_length);
+      !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
+      PACKET_1BYTE_PACKET_NUMBER, &payload_length);
   connection_.SetMaxPacketLength(length);
 
   // Queue the first packet.
   EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _))
       .WillOnce(testing::Return(QuicTime::Delta::FromMicroseconds(10)));
   const string payload(payload_length, 'a');
   EXPECT_EQ(0u,
             connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
                 .bytes_consumed);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_P(QuicConnectionTest, LoopThroughSendingPackets) {
   // All packets carry version info till version is negotiated.
   size_t payload_length;
   // GetPacketLengthForOneStream() assumes a stream offset of 0 in determining
   // packet length. The size of the offset field in a stream frame is 0 for
   // offset 0, and 2 for non-zero offsets up through 16K. Increase
   // max_packet_length by 2 so that subsequent packets containing subsequent
   // stream frames with non-zero offets will fit within the packet length.
-  size_t length = 2 + GetPacketLengthForOneStream(
-                          connection_.version(), kIncludeVersion,
-                          !kIncludePathId, PACKET_8BYTE_CONNECTION_ID,
-                          PACKET_1BYTE_PACKET_NUMBER, &payload_length);
+  size_t length =
+      2 + GetPacketLengthForOneStream(
+              connection_.version(), kIncludeVersion, !kIncludePathId,
+              !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
+              PACKET_1BYTE_PACKET_NUMBER, &payload_length);
   connection_.SetMaxPacketLength(length);
 
   // Queue the first packet.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(7);
   // The first stream frame will have 2 fewer overhead bytes than the other six.
   const string payload(payload_length * 7 + 2, 'a');
   EXPECT_EQ(payload.size(),
             connection_.SendStreamDataWithString(1, payload, 0, !kFin, nullptr)
                 .bytes_consumed);
 }
 
 TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
   // Set up a larger payload than will fit in one packet.
   const string payload(connection_.max_packet_length(), 'a');
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
 
   // Now send some packets with no truncation.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
   EXPECT_EQ(payload.size(),
             connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
                 .bytes_consumed);
   // Track the size of the second packet here.  The overhead will be the largest
   // we see in this test, due to the non-truncated connection id.
   size_t non_truncated_packet_size = writer_->last_packet_size();
 
-  // Change to a 4 byte connection id.
+  // Change to a 0 byte connection id.
   QuicConfig config;
-  QuicConfigPeer::SetReceivedBytesForConnectionId(&config, 4);
-  connection_.SetFromConfig(config);
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
-  EXPECT_EQ(payload.size(),
-            connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
-                .bytes_consumed);
-  // Verify that we have 8 fewer bytes than in the non-truncated case.  The
-  // first packet got 4 bytes of extra payload due to the truncation, and the
-  // headers here are also 4 byte smaller.
-  EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() + 8);
-
-  // Change to a 1 byte connection id.
-  QuicConfigPeer::SetReceivedBytesForConnectionId(&config, 1);
-  connection_.SetFromConfig(config);
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
-  EXPECT_EQ(payload.size(),
-            connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
-                .bytes_consumed);
-  // Just like above, we save 7 bytes on payload, and 7 on truncation.
-  EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() + 7 * 2);
-
-  // Change to a 0 byte connection id.
   QuicConfigPeer::SetReceivedBytesForConnectionId(&config, 0);
   connection_.SetFromConfig(config);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
   EXPECT_EQ(payload.size(),
             connection_.SendStreamDataWithString(3, payload, 0, !kFin, nullptr)
                 .bytes_consumed);
   // Just like above, we save 8 bytes on payload, and 8 on truncation.
   EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() + 8 * 2);
 }
 
@@ skipping 1199 matching lines @@
   EXPECT_CALL(visitor_, OnConnectionClosed(_, _, _)).Times(1);
   connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
                               ConnectionCloseBehavior::SILENT_CLOSE);
   connection_.CloseConnection(QUIC_NO_ERROR, "no reason",
                               ConnectionCloseBehavior::SILENT_CLOSE);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net