QUIC: support diversified keys with version 33.

net/quic/quic_protocol.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_protocol.h"
 
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::numeric_limits;
 using std::ostream;
 using std::string;
 
 namespace net {
 
 const char* const kFinalOffsetHeaderKey = ":final-offset";
 
 size_t GetPacketHeaderSize(const QuicPacketHeader& header) {
   return GetPacketHeaderSize(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);
 }
 
 size_t GetPacketHeaderSize(QuicConnectionIdLength connection_id_length,
                            bool include_version,
                            bool include_path_id,
+                           bool include_diversification_nonce,
                            QuicPacketNumberLength packet_number_length) {
   return kPublicFlagsSize + connection_id_length +
          (include_version ? kQuicVersionSize : 0) +
          (include_path_id ? kQuicPathIdSize : 0) + packet_number_length +
+         (include_diversification_nonce ? kDiversificationNonceSize : 0) +
          kPrivateFlagsSize;
 }
 
 size_t GetStartOfEncryptedData(const QuicPacketHeader& header) {
   return GetPacketHeaderSize(header) - kPrivateFlagsSize;
 }
 
 size_t GetStartOfEncryptedData(QuicConnectionIdLength connection_id_length,
                                bool include_version,
                                bool include_path_id,
+                               bool include_diversification_nonce,
                                QuicPacketNumberLength packet_number_length) {
   // Encryption starts before private flags.
   return GetPacketHeaderSize(connection_id_length, include_version,
-                             include_path_id, packet_number_length) -
+                             include_path_id, include_diversification_nonce,
+                             packet_number_length) -
          kPrivateFlagsSize;
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader()
     : connection_id(0),
       connection_id_length(PACKET_8BYTE_CONNECTION_ID),
       multipath_flag(false),
       reset_flag(false),
       version_flag(false),
-      packet_number_length(PACKET_6BYTE_PACKET_NUMBER) {}
+      packet_number_length(PACKET_6BYTE_PACKET_NUMBER),
+      nonce(nullptr) {}
 
 QuicPacketPublicHeader::QuicPacketPublicHeader(
-    const QuicPacketPublicHeader& other)
-    : connection_id(other.connection_id),
-      connection_id_length(other.connection_id_length),
-      multipath_flag(other.multipath_flag),
-      reset_flag(other.reset_flag),
-      version_flag(other.version_flag),
-      packet_number_length(other.packet_number_length),
-      versions(other.versions) {}
+    const QuicPacketPublicHeader& other) = default;
 
 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
 
 QuicPacketHeader::QuicPacketHeader()
     : packet_number(0),
       path_id(kDefaultPathId),
       entropy_flag(false),
       entropy_hash(0),
       fec_flag(false),
       is_in_fec_group(NOT_IN_FEC_GROUP),
@@ skipping 110 matching lines @@
     case QUIC_VERSION_28:
       return MakeQuicTag('Q', '0', '2', '8');
     case QUIC_VERSION_29:
       return MakeQuicTag('Q', '0', '2', '9');
     case QUIC_VERSION_30:
       return MakeQuicTag('Q', '0', '3', '0');
     case QUIC_VERSION_31:
       return MakeQuicTag('Q', '0', '3', '1');
     case QUIC_VERSION_32:
       return MakeQuicTag('Q', '0', '3', '2');
+    case QUIC_VERSION_33:
+      return MakeQuicTag('Q', '0', '3', '3');
     default:
       // This shold be an ERROR because we should never attempt to convert an
       // invalid QuicVersion to be written to the wire.
       LOG(ERROR) << "Unsupported QuicVersion: " << version;
       return 0;
   }
 }
 
 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
@@ skipping 14 matching lines @@
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_25);
     RETURN_STRING_LITERAL(QUIC_VERSION_26);
     RETURN_STRING_LITERAL(QUIC_VERSION_27);
     RETURN_STRING_LITERAL(QUIC_VERSION_28);
     RETURN_STRING_LITERAL(QUIC_VERSION_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_30);
     RETURN_STRING_LITERAL(QUIC_VERSION_31);
     RETURN_STRING_LITERAL(QUIC_VERSION_32);
+    RETURN_STRING_LITERAL(QUIC_VERSION_33);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
 string QuicVersionVectorToString(const QuicVersionVector& versions) {
   string result = "";
   for (size_t i = 0; i < versions.size(); ++i) {
     if (i != 0) {
       result.append(",");
@@ skipping 18 matching lines @@
      << ", packet_number_length:" << header.public_header.packet_number_length
      << ", multipath_flag: " << header.public_header.multipath_flag
      << ", reset_flag: " << header.public_header.reset_flag
      << ", version_flag: " << header.public_header.version_flag;
   if (header.public_header.version_flag) {
     os << " version: ";
     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
       os << header.public_header.versions[i] << " ";
     }
   }
+  os << ", diversification_nonce: "
+     << (header.public_header.nonce == nullptr
+             ? "none"
+             : "0x" + base::HexEncode(*header.public_header.nonce,
+                                      kDiversificationNonceSize));
   os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", path_id: " << header.path_id
      << ", packet_number: " << header.packet_number
      << ", is_in_fec_group:" << header.is_in_fec_group
      << ", fec_group: " << header.fec_group << "}\n";
   return os;
 }
 
@@ skipping 394 matching lines @@
     : stream_id(stream_id) {}
 
 QuicPathCloseFrame::QuicPathCloseFrame(QuicPathId path_id) : path_id(path_id) {}
 
 QuicPacket::QuicPacket(char* buffer,
                        size_t length,
                        bool owns_buffer,
                        QuicConnectionIdLength connection_id_length,
                        bool includes_version,
                        bool includes_path_id,
+                       bool includes_diversification_nonce,
                        QuicPacketNumberLength packet_number_length)
     : QuicData(buffer, length, owns_buffer),
       buffer_(buffer),
       connection_id_length_(connection_id_length),
       includes_version_(includes_version),
       includes_path_id_(includes_path_id),
+      includes_diversification_nonce_(includes_diversification_nonce),
       packet_number_length_(packet_number_length) {}
 
 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer, size_t length)
     : QuicData(buffer, length) {}
 
 QuicEncryptedPacket::QuicEncryptedPacket(char* buffer,
                                          size_t length,
                                          bool owns_buffer)
     : QuicData(buffer, length, owns_buffer) {}
 
@@ skipping 25 matching lines @@
   memcpy(buffer, this->data(), this->length());
   return new QuicReceivedPacket(buffer, this->length(), receipt_time(), true);
 }
 
 ostream& operator<<(ostream& os, const QuicReceivedPacket& s) {
   os << s.length() << "-byte data";
   return os;
 }
 
 StringPiece QuicPacket::AssociatedData() const {
-  return StringPiece(data(), GetStartOfEncryptedData(
-                                 connection_id_length_, includes_version_,
-                                 includes_path_id_, packet_number_length_));
+  return StringPiece(
+      data(), GetStartOfEncryptedData(
+                  connection_id_length_, includes_version_, includes_path_id_,
+                  includes_diversification_nonce_, packet_number_length_));
 }
 
 StringPiece QuicPacket::Plaintext() const {
-  const size_t start_of_encrypted_data =
-      GetStartOfEncryptedData(connection_id_length_, includes_version_,
-                              includes_path_id_, packet_number_length_);
+  const size_t start_of_encrypted_data = GetStartOfEncryptedData(
+      connection_id_length_, includes_version_, includes_path_id_,
+      includes_diversification_nonce_, packet_number_length_);
   return StringPiece(data() + start_of_encrypted_data,
                      length() - start_of_encrypted_data);
 }
 
 AckListenerWrapper::AckListenerWrapper(QuicAckListenerInterface* listener,
                                        QuicPacketLength data_length)
     : ack_listener(listener), length(data_length) {
   DCHECK(listener != nullptr);
 }
 
@@ skipping 58 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       needs_padding(needs_padding),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net