QUIC: support diversified keys with version 33.

net/quic/quic_packet_creator.h

 // 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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them. If multipath enabled, only creates
 // packets on one path at the same time. Currently, next packet number is
 // tracked per-path.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
@@ skipping 54 matching lines @@
                     QuicFramer* framer,
                     QuicRandom* random_generator,
                     QuicBufferAllocator* buffer_allocator,
                     DelegateInterface* delegate);
 
   ~QuicPacketCreator();
 
   // Makes the framer not serialize the protocol version in sent packets.
   void StopSendingVersion();
 
+  // SetDiversificationNonce sets the nonce that will be sent in each public
+  // header of packets encrypted at the initial encryption level. Should only
+  // be called by servers.
+  void SetDiversificationNonce(const DiversificationNonce nonce);
+
   // Update the packet number length to use in future packets as soon as it
   // can be safely changed.
   // TODO(fayang): Directly set packet number length instead of compute it in
   // creator.
   void UpdatePacketNumberLength(QuicPacketNumber least_packet_awaited_by_peer,
                                 QuicPacketCount max_packets_in_flight);
 
   // The overhead the framing will add for a packet with one frame.
   static size_t StreamFramePacketOverhead(
       QuicConnectionIdLength connection_id_length,
       bool include_version,
       bool include_path_id,
+      bool include_diversification_nonce,
       QuicPacketNumberLength packet_number_length,
       QuicStreamOffset offset);
 
   // Returns false and flushes all pending frames if current open packet is
   // full.
   // If current packet is not full, converts a raw payload into a stream frame
   // that fits into the open packet and adds it to the packet.
   // The payload begins at |iov_offset| into the |iov|.
   bool ConsumeData(QuicStreamId id,
                    QuicIOVector iov,
@@ skipping 157 matching lines @@
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   void SerializePacket(char* encrypted_buffer, size_t buffer_len);
 
   // Called after a new SerialiedPacket is created to call the delegate's
   // OnSerializedPacket and reset state.
   void OnSerializedPacket();
 
   // Clears all fields of packet_ that should be cleared between serializations.
   void ClearPacket();
 
+  // Returns true if a diversification nonce should be included in the current
+  // packet's public header.
+  bool IncludeNonceInPublicHeader();
+
   // Does not own these delegates or the framer.
   DelegateInterface* delegate_;
   DebugDelegate* debug_delegate_;
   QuicFramer* framer_;
 
   std::unique_ptr<QuicRandomBoolSource> random_bool_source_;
   QuicBufferAllocator* const buffer_allocator_;
 
   // Controls whether version should be included while serializing the packet.
   bool send_version_in_packet_;
   // Controls whether path id should be included while serializing the packet.
   bool send_path_id_in_packet_;
   // Staging variable to hold next packet number length. When sequence
   // number length is to be changed, this variable holds the new length until
   // a packet boundary, when the creator's packet_number_length_ can be changed
   // to this new value.
   QuicPacketNumberLength next_packet_number_length_;
+  // If true, then |nonce_for_public_header_| will be included in the public
+  // header of all packets created at the initial encryption level.
+  bool have_diversification_nonce_;
+  DiversificationNonce diversification_nonce_;
   // Maximum length including headers and encryption (UDP payload length.)
   QuicByteCount max_packet_length_;
   size_t max_plaintext_size_;
   // Length of connection_id to send over the wire.
   QuicConnectionIdLength connection_id_length_;
 
   // Frames to be added to the next SerializedPacket
   QuicFrames queued_frames_;
 
   // packet_size should never be read directly, use PacketSize() instead.
   // TODO(ianswett): Move packet_size_ into SerializedPacket once
   // QuicEncryptedPacket has been flattened into SerializedPacket.
   size_t packet_size_;
   QuicConnectionId connection_id_;
 
   // Packet used to invoke OnSerializedPacket.
   SerializedPacket packet_;
 
   // Map mapping path_id to last sent packet number on the path.
   std::unordered_map<QuicPathId, QuicPacketNumber> multipath_packet_number_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_