QUIC: support diversified keys with version 33.

net/quic/quic_framer.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_framer.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/compiler_specific.h"
@@ skipping 21 matching lines @@
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a packet number.
 const QuicPacketNumber k6ByteSequenceNumberMask = UINT64_C(0x0000FFFFFFFFFFFF);
 const QuicPacketNumber k4ByteSequenceNumberMask = UINT64_C(0x00000000FFFFFFFF);
 const QuicPacketNumber k2ByteSequenceNumberMask = UINT64_C(0x000000000000FFFF);
 const QuicPacketNumber k1ByteSequenceNumberMask = UINT64_C(0x00000000000000FF);
 
-const QuicConnectionId k1ByteConnectionIdMask = UINT64_C(0x00000000000000FF);
-const QuicConnectionId k4ByteConnectionIdMask = UINT64_C(0x00000000FFFFFFFF);
-
 // Number of bits the packet number length bits are shifted from the right
 // edge of the public header.
 const uint8_t kPublicHeaderSequenceNumberShift = 4;
 
 // New Frame Types, QUIC v. >= 10:
 // There are two interpretations for the Frame Type byte in the QUIC protocol,
 // resulting in two Frame Types: Special Frame Types and Regular Frame Types.
 //
 // Regular Frame Types use the Frame Type byte simply. Currently defined
 // Regular Frame Types are:
@@ skipping 591 matching lines @@
     public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
   if (header.public_header.multipath_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_MULTIPATH;
   }
 
   public_flags |=
       GetSequenceNumberFlags(header.public_header.packet_number_length)
       << kPublicHeaderSequenceNumberShift;
 
+  if (header.public_header.nonce != nullptr) {
+    DCHECK_EQ(Perspective::IS_SERVER, perspective_);
+    public_flags |= PACKET_PUBLIC_FLAGS_NONCE;
+  }
+
   switch (header.public_header.connection_id_length) {
     case PACKET_0BYTE_CONNECTION_ID:
       if (!writer->WriteUInt8(public_flags |
                               PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
         return false;
       }
       break;
-    case PACKET_1BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(public_flags |
-                              PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) {
-        return false;
-      }
-      if (!writer->WriteUInt8(header.public_header.connection_id &
-                              k1ByteConnectionIdMask)) {
-        return false;
-      }
-      break;
-    case PACKET_4BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(public_flags |
-                              PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) {
-        return false;
-      }
-      if (!writer->WriteUInt32(header.public_header.connection_id &
-                               k4ByteConnectionIdMask)) {
-        return false;
-      }
-      break;
     case PACKET_8BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(public_flags |
-                              PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) {
-        return false;
+      if (quic_version_ > QUIC_VERSION_32) {
+        public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
+      } else {
+        public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID_OLD;
       }
-      if (!writer->WriteUInt64(header.public_header.connection_id)) {
+      if (!writer->WriteUInt8(public_flags) ||
+          !writer->WriteUInt64(header.public_header.connection_id)) {
         return false;
       }
       break;
   }
   last_serialized_connection_id_ = header.public_header.connection_id;
 
   if (header.public_header.version_flag) {
     DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
     QuicTag tag = QuicVersionToQuicTag(quic_version_);
     writer->WriteUInt32(tag);
     DVLOG(1) << "version = " << quic_version_ << ", tag = '"
              << QuicUtils::TagToString(tag) << "'";
   }
 
   if (header.public_header.multipath_flag &&
       !writer->WriteUInt8(header.path_id)) {
     return false;
   }
 
+  if (header.public_header.nonce != nullptr &&
+      !writer->WriteBytes(header.public_header.nonce,
+                          kDiversificationNonceSize)) {
+    return false;
+  }
+
   if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
                                   header.packet_number, writer)) {
     return false;
   }
 
   uint8_t private_flags = 0;
   if (header.entropy_flag) {
     private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
   }
   if (!writer->WriteUInt8(private_flags)) {
@@ skipping 102 matching lines @@
   }
 
   switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) {
     case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID:
       if (!reader->ReadUInt64(&public_header->connection_id)) {
         set_detailed_error("Unable to read ConnectionId.");
         return false;
       }
       public_header->connection_id_length = PACKET_8BYTE_CONNECTION_ID;
       break;
-    case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID:
-      // If the connection_id is truncated, expect to read the last serialized
-      // connection_id.
-      if (!reader->ReadBytes(&public_header->connection_id,
-                             PACKET_4BYTE_CONNECTION_ID)) {
-        set_detailed_error("Unable to read ConnectionId.");
-        return false;
-      }
-      if (last_serialized_connection_id_ &&
-          (public_header->connection_id & k4ByteConnectionIdMask) !=
-              (last_serialized_connection_id_ & k4ByteConnectionIdMask)) {
-        set_detailed_error(
-            "Truncated 4 byte ConnectionId does not match "
-            "previous connection_id.");
-        return false;
-      }
-      public_header->connection_id_length = PACKET_4BYTE_CONNECTION_ID;
-      public_header->connection_id = last_serialized_connection_id_;
-      break;
-    case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID:
-      if (!reader->ReadBytes(&public_header->connection_id,
-                             PACKET_1BYTE_CONNECTION_ID)) {
-        set_detailed_error("Unable to read ConnectionId.");
-        return false;
-      }
-      if (last_serialized_connection_id_ &&
-          (public_header->connection_id & k1ByteConnectionIdMask) !=
-              (last_serialized_connection_id_ & k1ByteConnectionIdMask)) {
-        set_detailed_error(
-            "Truncated 1 byte ConnectionId does not match "
-            "previous connection_id.");
-        return false;
-      }
-      public_header->connection_id_length = PACKET_1BYTE_CONNECTION_ID;
-      public_header->connection_id = last_serialized_connection_id_;
-      break;
     case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
       public_header->connection_id_length = PACKET_0BYTE_CONNECTION_ID;
       public_header->connection_id = last_serialized_connection_id_;
       break;
   }
 
   public_header->packet_number_length = ReadSequenceNumberLength(
       public_flags >> kPublicHeaderSequenceNumberShift);
 
   // Read the version only if the packet is from the client.
   // version flag from the server means version negotiation packet.
   if (public_header->version_flag && perspective_ == Perspective::IS_SERVER) {
     QuicTag version_tag;
     if (!reader->ReadUInt32(&version_tag)) {
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
 
     // If the version from the new packet is the same as the version of this
     // framer, then the public flags should be set to something we understand.
     // If not, this raises an error.
     last_version_tag_ = version_tag;
     QuicVersion version = QuicTagToQuicVersion(version_tag);
     if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
       set_detailed_error("Illegal public flags value.");
       return false;
     }
     public_header->versions.push_back(version);
   }
+
+  // A nonce should only be present in packets from the server to the client,
+  // and only for versions after QUIC_VERSION_32. Earlier versions will
+  // set this bit when indicating an 8-byte connection ID, which should
+  // not be interpreted as indicating a nonce is present.
+  if (quic_version_ > QUIC_VERSION_32 &&
+      public_flags & PACKET_PUBLIC_FLAGS_NONCE &&
+      // The nonce flag from a client is ignored and is assumed to be an older
+      // client indicating an eight-byte connection ID.
+      perspective_ == Perspective::IS_CLIENT) {
+    if (!reader->ReadBytes(reinterpret_cast<uint8_t*>(last_nonce_),
+                           sizeof(last_nonce_))) {
+      set_detailed_error("Unable to read nonce.");
+      return false;
+    }
+    public_header->nonce = &last_nonce_;
+  } else {
+    public_header->nonce = nullptr;
+  }
+
   return true;
 }
 
 // static
 QuicPacketNumberLength QuicFramer::GetMinSequenceNumberLength(
     QuicPacketNumber packet_number) {
   if (packet_number < 1 << (PACKET_1BYTE_PACKET_NUMBER * 8)) {
     return PACKET_1BYTE_PACKET_NUMBER;
   } else if (packet_number < 1 << (PACKET_2BYTE_PACKET_NUMBER * 8)) {
     return PACKET_2BYTE_PACKET_NUMBER;
@@ skipping 703 matching lines @@
 
   return true;
 }
 
 // static
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted,
     QuicConnectionIdLength connection_id_length,
     bool includes_version,
     bool includes_path_id,
+    bool includes_diversification_nonce,
     QuicPacketNumberLength packet_number_length) {
   // TODO(ianswett): This is identical to QuicData::AssociatedData.
   return StringPiece(
       encrypted.data(),
       GetStartOfEncryptedData(connection_id_length, includes_version,
-                              includes_path_id, packet_number_length));
+                              includes_path_id, includes_diversification_nonce,
+                              packet_number_length));
 }
 
 void QuicFramer::SetDecrypter(EncryptionLevel level, QuicDecrypter* decrypter) {
   DCHECK(alternative_decrypter_.get() == nullptr);
   DCHECK_GE(level, decrypter_level_);
   decrypter_.reset(decrypter);
   decrypter_level_ = level;
 }
 
 void QuicFramer::SetAlternativeDecrypter(EncryptionLevel level,
@@ skipping 85 matching lines @@
                                 const QuicPacketHeader& header,
                                 const QuicEncryptedPacket& packet,
                                 char* decrypted_buffer,
                                 size_t buffer_length,
                                 size_t* decrypted_length) {
   StringPiece encrypted = encrypted_reader->ReadRemainingPayload();
   DCHECK(decrypter_.get() != nullptr);
   StringPiece associated_data = GetAssociatedDataFromEncryptedPacket(
       packet, header.public_header.connection_id_length,
       header.public_header.version_flag, header.public_header.multipath_flag,
+      header.public_header.nonce != nullptr,
       header.public_header.packet_number_length);
+
   bool success = decrypter_->DecryptPacket(
       header.path_id, header.packet_number, associated_data, encrypted,
       decrypted_buffer, decrypted_length, buffer_length);
   if (success) {
     visitor_->OnDecryptedPacket(decrypter_level_);
   } else if (alternative_decrypter_.get() != nullptr) {
+    if (header.public_header.nonce != nullptr) {
+      DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
+      alternative_decrypter_->SetDiversificationNonce(
+          *header.public_header.nonce);
+    }
+    if (alternative_decrypter_level_ == ENCRYPTION_INITIAL) {
+      if (perspective_ == Perspective::IS_CLIENT &&
+          quic_version_ > QUIC_VERSION_32) {
+        DCHECK(header.public_header.nonce != nullptr);
+      } else {
+        DCHECK(header.public_header.nonce == nullptr);
+      }
+    }
+
     success = alternative_decrypter_->DecryptPacket(
         header.path_id, header.packet_number, associated_data, encrypted,
         decrypted_buffer, decrypted_length, buffer_length);
     if (success) {
       visitor_->OnDecryptedPacket(alternative_decrypter_level_);
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
         decrypter_level_ = alternative_decrypter_level_;
@@ skipping 511 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net