Add QUIC 31 in which the server's proof covers both the static server config as well as a hash of t…

net/quic/crypto/quic_crypto_server_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/crypto/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 
@@ skipping 589 matching lines @@
     *error_details = validate_chlo_result.error_details;
     return validate_chlo_result.error_code;
   }
 
   out->Clear();
 
   bool x509_supported = false;
   bool x509_ecdsa_supported = false;
   ParseProofDemand(client_hello, &x509_supported, &x509_ecdsa_supported);
   DCHECK(proof_source_.get());
+  string chlo_hash;
+  CryptoUtils::HashHandshakeMessage(client_hello, &chlo_hash);
   if (!crypto_proof->chain &&
-      !proof_source_->GetProof(server_ip, info.sni.as_string(),
-                               primary_config->serialized, x509_ecdsa_supported,
-                               &crypto_proof->chain, &crypto_proof->signature,
-                               &crypto_proof->cert_sct)) {
+      !proof_source_->GetProof(
+          server_ip, info.sni.as_string(), primary_config->serialized, version,
+          chlo_hash, x509_ecdsa_supported, &crypto_proof->chain,
+          &crypto_proof->signature, &crypto_proof->cert_sct)) {
     return QUIC_HANDSHAKE_FAILED;
   }
 
   if (version > QUIC_VERSION_29) {
     StringPiece cert_sct;
     if (client_hello.GetStringPiece(kCertificateSCTTag, &cert_sct) &&
         cert_sct.empty()) {
       params->sct_supported_by_client = true;
     }
   }
@@ skipping 429 matching lines @@
       return;
     }
     found_error = true;
   }
 
   if (version > QUIC_VERSION_25) {
     bool x509_supported = false;
     bool x509_ecdsa_supported = false;
     ParseProofDemand(client_hello, &x509_supported, &x509_ecdsa_supported);
     string serialized_config = primary_config->serialized;
-    if (!proof_source_->GetProof(server_ip, info->sni.as_string(),
-                                 serialized_config, x509_ecdsa_supported,
-                                 &crypto_proof->chain, &crypto_proof->signature,
-                                 &crypto_proof->cert_sct)) {
+    string chlo_hash;
+    CryptoUtils::HashHandshakeMessage(client_hello, &chlo_hash);
+    if (!proof_source_->GetProof(
+            server_ip, info->sni.as_string(), serialized_config, version,
+            chlo_hash, x509_ecdsa_supported, &crypto_proof->chain,
+            &crypto_proof->signature, &crypto_proof->cert_sct)) {
       found_error = true;
       info->reject_reasons.push_back(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE);
     }
 
     if (!ValidateExpectedLeafCertificate(client_hello, *crypto_proof)) {
       found_error = true;
       info->reject_reasons.push_back(INVALID_EXPECTED_LEAF_CERTIFICATE);
     }
   }
 
   if (!client_hello.GetStringPiece(kNONC, &info->client_nonce) ||
       info->client_nonce.size() != kNonceSize) {
     info->reject_reasons.push_back(CLIENT_NONCE_INVALID_FAILURE);
     // Invalid client nonce.
     DVLOG(1) << "Invalid client nonce.";
     if (FLAGS_use_early_return_when_verifying_chlo) {
       helper.ValidationComplete(QUIC_NO_ERROR, "");
       return;
     }
     found_error = true;
   }
 
   // Server nonce is optional, and used for key derivation if present.
   client_hello.GetStringPiece(kServerNonceTag, &info->server_nonce);
 
-  if (version > QUIC_VERSION_30) {
-    DVLOG(1) << "No 0-RTT replay protection in QUIC_VERSION_31 and higher.";
+  if (version > QUIC_VERSION_31) {
+    DVLOG(1) << "No 0-RTT replay protection in QUIC_VERSION_32 and higher.";
     // If the server nonce is empty and we're requiring handshake confirmation
     // for DoS reasons then we must reject the CHLO.
     if (FLAGS_quic_require_handshake_confirmation &&
         info->server_nonce.empty()) {
       info->reject_reasons.push_back(SERVER_NONCE_REQUIRED_FAILURE);
     }
     helper.ValidationComplete(QUIC_NO_ERROR, "");
     return;
   }
 
@@ skipping 80 matching lines @@
   out->SetStringPiece(kSCFG, primary_config_->serialized);
   out->SetStringPiece(
       kSourceAddressTokenTag,
       NewSourceAddressToken(*primary_config_.get(),
                             previous_source_address_tokens, client_ip, rand,
                             clock->WallNow(), cached_network_params));
 
   scoped_refptr<ProofSource::Chain> chain;
   string signature;
   string cert_sct;
-  if (!proof_source_->GetProof(
-          server_ip, params.sni, primary_config_->serialized,
-          params.x509_ecdsa_supported, &chain, &signature, &cert_sct)) {
+  if (!proof_source_->GetProof(server_ip, params.sni,
+                               primary_config_->serialized, version,
+                               params.client_nonce, params.x509_ecdsa_supported,
+                               &chain, &signature, &cert_sct)) {
     DVLOG(1) << "Server: failed to get proof.";
     return false;
   }
 
   const string compressed = CertCompressor::CompressChain(
       chain->certs, params.client_common_set_hashes,
       params.client_cached_cert_hashes, primary_config_->common_cert_sets);
 
   out->SetStringPiece(kCertificateTag, compressed);
   out->SetStringPiece(kPROF, signature);
@@ skipping 598 matching lines @@
       priority(0),
       source_address_token_boxer(nullptr) {}
 
 QuicCryptoServerConfig::Config::~Config() {
   STLDeleteElements(&key_exchanges);
 }
 
 QuicCryptoProof::QuicCryptoProof() {}
 QuicCryptoProof::~QuicCryptoProof() {}
 }  // namespace net