Remove path id from IV in QUIC encrytion algorithms.

net/quic/core/quic_framer_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/core/quic_framer.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <memory>
@@ skipping 95 matching lines @@
 // Public resets always have full connection_ids.
 const size_t kPublicResetPacketMessageTagOffset =
     kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID;
 
 class TestEncrypter : public QuicEncrypter {
  public:
   ~TestEncrypter() override {}
   bool SetKey(StringPiece key) override { return true; }
   bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
   bool EncryptPacket(QuicVersion version,
-                     QuicPathId path_id,
                      QuicPacketNumber packet_number,
                      StringPiece associated_data,
                      StringPiece plaintext,
                      char* output,
                      size_t* output_length,
                      size_t max_output_length) override {
     version_ = version;
-    path_id_ = path_id;
     packet_number_ = packet_number;
     associated_data_ = associated_data.as_string();
     plaintext_ = plaintext.as_string();
     memcpy(output, plaintext.data(), plaintext.length());
     *output_length = plaintext.length();
     return true;
   }
   size_t GetKeySize() const override { return 0; }
   size_t GetNoncePrefixSize() const override { return 0; }
   size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
     return ciphertext_size;
   }
   size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size;
   }
   StringPiece GetKey() const override { return StringPiece(); }
   StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
   QuicVersion version_;
   Perspective perspective_;
-  QuicPathId path_id_;
   QuicPacketNumber packet_number_;
   string associated_data_;
   string plaintext_;
 };
 
 class TestDecrypter : public QuicDecrypter {
  public:
   ~TestDecrypter() override {}
   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(const DiversificationNonce& key) override {
     return true;
   }
   bool DecryptPacket(QuicVersion version,
-                     QuicPathId path_id,
                      QuicPacketNumber packet_number,
                      StringPiece associated_data,
                      StringPiece ciphertext,
                      char* output,
                      size_t* output_length,
                      size_t max_output_length) override {
     version_ = version;
-    path_id_ = path_id;
     packet_number_ = packet_number;
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     memcpy(output, ciphertext.data(), ciphertext.length());
     *output_length = ciphertext.length();
     return true;
   }
   StringPiece GetKey() const override { return StringPiece(); }
   StringPiece GetNoncePrefix() const override { return StringPiece(); }
   const char* cipher_name() const override { return "Test"; }
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
   uint32_t cipher_id() const override { return 0xFFFFFFF2; }
   QuicVersion version_;
   Perspective perspective_;
-  QuicPathId path_id_;
   QuicPacketNumber packet_number_;
   string associated_data_;
   string ciphertext_;
 };
 
 class TestQuicVisitor : public QuicFramerVisitorInterface {
  public:
   TestQuicVisitor()
       : error_count_(0),
         version_mismatch_(0),
@@ skipping 3567 matching lines @@
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
       !kIncludeVersion, !kIncludePathId, !kIncludeDiversificationNonce,
       PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
-  size_t encrypted_length =
-      framer_.EncryptPayload(ENCRYPTION_NONE, kDefaultPathId, packet_number,
-                             *raw, buffer, kMaxPacketSize);
+  size_t encrypted_length = framer_.EncryptPayload(
+      ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(kDefaultPathId, packet_number, raw.get()));
 }
 
 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
@@ skipping 13 matching lines @@
     'i',  'j',  'k',  'l',
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
       kIncludeVersion, !kIncludePathId, !kIncludeDiversificationNonce,
       PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
-  size_t encrypted_length =
-      framer_.EncryptPayload(ENCRYPTION_NONE, kDefaultPathId, packet_number,
-                             *raw, buffer, kMaxPacketSize);
+  size_t encrypted_length = framer_.EncryptPayload(
+      ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(kDefaultPathId, packet_number, raw.get()));
 }
 
 TEST_P(QuicFramerTest, EncryptPacketWithMultipathFlag) {
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
@@ skipping 14 matching lines @@
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
       !kIncludeVersion, kIncludePathId, !kIncludeDiversificationNonce,
       PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_NONE, kPathId, packet_number, *raw, buffer, kMaxPacketSize);
+      ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(kPathId, packet_number, raw.get()));
 }
 
 TEST_P(QuicFramerTest, EncryptPacketWithBothVersionFlagAndMultipathFlag) {
   QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
@@ skipping 16 matching lines @@
     'm',  'n',  'o',  'p',
   };
   // clang-format on
 
   std::unique_ptr<QuicPacket> raw(new QuicPacket(
       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
       kIncludeVersion, kIncludePathId, !kIncludeDiversificationNonce,
       PACKET_6BYTE_PACKET_NUMBER));
   char buffer[kMaxPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_NONE, kPathId, packet_number, *raw, buffer, kMaxPacketSize);
+      ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(kPathId, packet_number, raw.get()));
 }
 
 TEST_P(QuicFramerTest, AckTruncationLargePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   // Create a packet with just the ack.
   ack_frame = MakeAckFrameWithAckBlocks(300, 0u);
   QuicFrames frames = {QuicFrame(&ack_frame)};
 
   // Build an ack packet with truncation due to limit in number of nack ranges.
   std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
   ASSERT_TRUE(raw_ack_packet != nullptr);
   char buffer[kMaxPacketSize];
-  size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_NONE, kDefaultPathId, header.packet_number, *raw_ack_packet,
-      buffer, kMaxPacketSize);
+  size_t encrypted_length =
+      framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_number,
+                             *raw_ack_packet, buffer, kMaxPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(600u, processed_ack_frame.largest_observed);
   ASSERT_EQ(256u, processed_ack_frame.packets.NumPacketsSlow());
   EXPECT_EQ(90u, processed_ack_frame.packets.Min());
   EXPECT_EQ(600u, processed_ack_frame.packets.Max());
 }
 
 TEST_P(QuicFramerTest, AckTruncationSmallPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.packet_number = kPacketNumber;
 
   // Create a packet with just the ack.
   QuicAckFrame ack_frame;
   ack_frame = MakeAckFrameWithAckBlocks(300, 0u);
   QuicFrames frames = {QuicFrame(&ack_frame)};
 
   // Build an ack packet with truncation due to limit in number of nack ranges.
   std::unique_ptr<QuicPacket> raw_ack_packet(
       BuildDataPacket(header, frames, 500));
   ASSERT_TRUE(raw_ack_packet != nullptr);
   char buffer[kMaxPacketSize];
-  size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_NONE, kDefaultPathId, header.packet_number, *raw_ack_packet,
-      buffer, kMaxPacketSize);
+  size_t encrypted_length =
+      framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_number,
+                             *raw_ack_packet, buffer, kMaxPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(600u, processed_ack_frame.largest_observed);
   ASSERT_EQ(239u, processed_ack_frame.packets.NumPacketsSlow());
   EXPECT_EQ(124u, processed_ack_frame.packets.Min());
   EXPECT_EQ(600u, processed_ack_frame.packets.Max());
@@ skipping 10 matching lines @@
   ack_frame.largest_observed = 201;
   ack_frame.packets.Add(1, ack_frame.largest_observed);
 
   // Create a packet with just the ack.
   QuicFrames frames = {QuicFrame(&ack_frame)};
 
   std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
   ASSERT_TRUE(raw_ack_packet != nullptr);
 
   char buffer[kMaxPacketSize];
-  size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_NONE, kDefaultPathId, header.packet_number, *raw_ack_packet,
-      buffer, kMaxPacketSize);
+  size_t encrypted_length =
+      framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_number,
+                             *raw_ack_packet, buffer, kMaxPacketSize);
   ASSERT_NE(0u, encrypted_length);
 
   // Now make sure we can turn our ack packet back into an ack frame.
   ASSERT_TRUE(framer_.ProcessPacket(
       QuicEncryptedPacket(buffer, encrypted_length, false)));
 
   // Test for clean truncation of the ack by comparing the length of the
   // original packets to the re-serialized packets.
   frames.clear();
   frames.push_back(QuicFrame(visitor_.ack_frames_[0].get()));
@@ skipping 201 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net