QUIC - Persist "Hash of the CHLO message" and "Signed timestamp of the

net/quic/crypto/quic_server_info.cc

 // Copyright 2014 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/crypto/quic_server_info.h"
 
 #include <limits>
 
 #include "base/pickle.h"
 
 using std::string;
 
 namespace {
 
-const int kQuicCryptoConfigVersion = 1;
+const int kQuicCryptoConfigVersion = 2;
 
 }  // namespace
 
 namespace net {
 
 QuicServerInfo::State::State() {}
 
 QuicServerInfo::State::~State() {}
 
 void QuicServerInfo::State::Clear() {
   server_config.clear();
   source_address_token.clear();
+  cert_sct.clear();
+  chlo_hash.clear();
   server_config_sig.clear();
   certs.clear();
 }
 
 QuicServerInfo::QuicServerInfo(const QuicServerId& server_id)
     : server_id_(server_id) {}
 
 QuicServerInfo::~QuicServerInfo() {}
 
 const QuicServerInfo::State& QuicServerInfo::state() const {
@@ skipping 38 matching lines @@
   }
 
   if (!iter.ReadString(&state->server_config)) {
     DVLOG(1) << "Malformed server_config";
     return false;
   }
   if (!iter.ReadString(&state->source_address_token)) {
     DVLOG(1) << "Malformed source_address_token";
     return false;
   }
+  if (!iter.ReadString(&state->cert_sct)) {

[ramant (doing other things), 2016/03/23 01:56:02]

Hi Ryan,
  Should we load older versions and initialize cert_sct and chlo_hash as empty
strings for older versions (kQuicCryptoConfigVersion = 1)?

[Ryan Hamilton, 2016/03/23 13:55:44]

That sounds fine, since that's what we're doing today, right?

[ramant (doing other things), 2016/03/23 22:43:42]

Done.

+    DVLOG(1) << "Malformed cert_sct";
+    return false;
+  }
+  if (!iter.ReadString(&state->chlo_hash)) {
+    DVLOG(1) << "Malformed chlo_hash";
+    return false;
+  }
   if (!iter.ReadString(&state->server_config_sig)) {
     DVLOG(1) << "Malformed server_config_sig";
     return false;
   }
 
   // Read certs.
   uint32_t num_certs;
   if (!iter.ReadUInt32(&num_certs)) {
     DVLOG(1) << "Malformed num_certs";
     return false;
@@ skipping 16 matching lines @@
   state_.Clear();
   return pickled_data;
 }
 
 string QuicServerInfo::SerializeInner() const {
   base::Pickle p(sizeof(base::Pickle::Header));
 
   if (!p.WriteInt(kQuicCryptoConfigVersion) ||
       !p.WriteString(state_.server_config) ||
       !p.WriteString(state_.source_address_token) ||
+      !p.WriteString(state_.cert_sct) || !p.WriteString(state_.chlo_hash) ||
       !p.WriteString(state_.server_config_sig) ||
       state_.certs.size() > std::numeric_limits<uint32_t>::max() ||
       !p.WriteUInt32(state_.certs.size())) {
     return string();
   }
 
   for (size_t i = 0; i < state_.certs.size(); i++) {
     if (!p.WriteString(state_.certs[i])) {
       return string();
     }
   }
 
   return string(reinterpret_cast<const char*>(p.data()), p.size());
 }
 
 QuicServerInfoFactory::~QuicServerInfoFactory() {}
 
 }  // namespace net