Store the QUIC server's crypto config expiration time explicitly in the client's CachedState, inste…

net/quic/core/crypto/quic_crypto_client_config.cc

 // Copyright 2013 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/crypto/quic_crypto_client_config.h"
 
 #include <memory>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 48 matching lines @@
     : proof_verifier_(std::move(proof_verifier)) {
   DCHECK(proof_verifier_.get());
   SetDefaults();
 }
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   base::STLDeleteValues(&cached_states_);
 }
 
 QuicCryptoClientConfig::CachedState::CachedState()
-    : server_config_valid_(false), generation_counter_(0) {}
+    : server_config_valid_(false),
+      expiration_time_(QuicWallTime::Zero()),
+      generation_counter_(0) {}
 
 QuicCryptoClientConfig::CachedState::~CachedState() {}
 
 bool QuicCryptoClientConfig::CachedState::IsComplete(QuicWallTime now) const {
   if (server_config_.empty()) {
     RecordInchoateClientHelloReason(SERVER_CONFIG_EMPTY);
     return false;
   }
 
   if (!server_config_valid_) {
     RecordInchoateClientHelloReason(SERVER_CONFIG_INVALID);
     return false;
   }
 
   const CryptoHandshakeMessage* scfg = GetServerConfig();
   if (!scfg) {
     // Should be impossible short of cache corruption.
     DCHECK(false);
     RecordInchoateClientHelloReason(SERVER_CONFIG_CORRUPTED);
     return false;
   }
 
-  uint64_t expiry_seconds;
-  if (scfg->GetUint64(kEXPY, &expiry_seconds) != QUIC_NO_ERROR) {
-    RecordInchoateClientHelloReason(SERVER_CONFIG_INVALID_EXPIRY);
-    return false;
-  }
-  if (now.ToUNIXSeconds() >= expiry_seconds) {
+  if (now.IsAfter(expiration_time_)) {
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "Net.QuicClientHelloServerConfig.InvalidDuration",
-        base::TimeDelta::FromSeconds(now.ToUNIXSeconds() - expiry_seconds),
+        base::TimeDelta::FromSeconds(now.ToUNIXSeconds() -
+                                     expiration_time_.ToUNIXSeconds()),
         base::TimeDelta::FromMinutes(1), base::TimeDelta::FromDays(20), 50);
     RecordInchoateClientHelloReason(SERVER_CONFIG_EXPIRED);
     return false;
   }
 
   return true;
 }
 
 bool QuicCryptoClientConfig::CachedState::IsEmpty() const {
   return server_config_.empty();
@@ skipping 52 matching lines @@
   if (!new_scfg) {
     *error_details = "SCFG invalid";
     return SERVER_CONFIG_INVALID;
   }
 
   uint64_t expiry_seconds;
   if (new_scfg->GetUint64(kEXPY, &expiry_seconds) != QUIC_NO_ERROR) {
     *error_details = "SCFG missing EXPY";
     return SERVER_CONFIG_INVALID_EXPIRY;
   }
+  expiration_time_ = QuicWallTime::FromUNIXSeconds(expiry_seconds);
 
-  if (now.ToUNIXSeconds() >= expiry_seconds) {
+  if (now.IsAfter(expiration_time_)) {
     *error_details = "SCFG has expired";
     return SERVER_CONFIG_EXPIRED;
   }
 
   if (!matches_existing) {
     server_config_ = server_config.as_string();
     SetProofInvalid();
     scfg_.reset(new_scfg_storage.release());
   }
   return SERVER_CONFIG_VALID;
@@ skipping 794 matching lines @@
   }
 
   // Update canonical version to point at the "most recent" entry.
   canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
   return true;
 }
 
 }  // namespace net