relnote: remove insecure QUIC support

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>
 
 #include "base/stl_util.h"
@@ skipping 197 matching lines @@
   delete this;
 }
 
 QuicCryptoServerConfig::ConfigOptions::ConfigOptions()
     : expiry_time(QuicWallTime::Zero()),
       channel_id_enabled(false),
       p256(false) {}
 
 QuicCryptoServerConfig::QuicCryptoServerConfig(
     StringPiece source_address_token_secret,
-    QuicRandom* rand)
+    QuicRandom* server_nonce_entropy,
+    ProofSource* proof_source)
     : replay_protection_(true),
       configs_lock_(),
       primary_config_(nullptr),
       next_config_promotion_time_(QuicWallTime::Zero()),
       server_nonce_strike_register_lock_(),
+      proof_source_(proof_source),
       strike_register_no_startup_period_(false),
       strike_register_max_entries_(1 << 10),
       strike_register_window_secs_(600),
       source_address_token_future_secs_(3600),
       source_address_token_lifetime_secs_(86400),
       server_nonce_strike_register_max_entries_(1 << 10),
       server_nonce_strike_register_window_secs_(120) {
+  DCHECK(proof_source_.get());
   default_source_address_token_boxer_.SetKey(
       DeriveSourceAddressTokenKey(source_address_token_secret));
 
   // Generate a random key and orbit for server nonces.
-  rand->RandBytes(server_nonce_orbit_, sizeof(server_nonce_orbit_));
+  server_nonce_entropy->RandBytes(server_nonce_orbit_,
+                                  sizeof(server_nonce_orbit_));
   const size_t key_size = server_nonce_boxer_.GetKeySize();
   scoped_ptr<uint8[]> key_bytes(new uint8[key_size]);
-  rand->RandBytes(key_bytes.get(), key_size);
+  server_nonce_entropy->RandBytes(key_bytes.get(), key_size);
 
   server_nonce_boxer_.SetKey(
       StringPiece(reinterpret_cast<char*>(key_bytes.get()), key_size));
 }
 
 QuicCryptoServerConfig::~QuicCryptoServerConfig() {
   primary_config_ = nullptr;
 }
 
 // static
@@ skipping 353 matching lines @@
   if (validate_chlo_result.error_code != QUIC_NO_ERROR) {
     *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);
-  if (proof_source_.get() && !crypto_proof->certs &&
+  DCHECK(proof_source_.get());
+  if (!crypto_proof->certs &&
       !proof_source_->GetProof(server_ip, info.sni.as_string(),
                                primary_config->serialized, x509_ecdsa_supported,
                                &crypto_proof->certs,
                                &crypto_proof->signature)) {
     return QUIC_HANDSHAKE_FAILED;
   }
 
   if (!info.valid_source_address_token ||
       !info.client_nonce_well_formed ||
       !info.unique ||
@@ skipping 58 matching lines @@
   hkdf_suffix.append(reinterpret_cast<char*>(&connection_id),
                      sizeof(connection_id));
   hkdf_suffix.append(client_hello_serialized.data(),
                      client_hello_serialized.length());
   hkdf_suffix.append(requested_config->serialized);
   // The addition of x509_supported in this if statement is so that an insecure
   // quic client talking to a secure quic server will not result in the secure
   // quic server adding the cert to the kdf.
   // TODO(nharper): Should a server that is configured to be secure (i.e. one
   // that has a proof_source_) be accepting responses from an insecure client?
-  if (version > QUIC_VERSION_25 && proof_source_.get() && x509_supported) {
+  DCHECK(proof_source_.get());
+  if (version > QUIC_VERSION_25 && x509_supported) {
     if (crypto_proof->certs->empty()) {
       *error_details = "Failed to get certs";
       return QUIC_CRYPTO_INTERNAL_ERROR;
     }
     hkdf_suffix.append(crypto_proof->certs->at(0));
   }
 
   StringPiece cetv_ciphertext;
   if (requested_config->channel_id_enabled &&
       client_hello.GetStringPiece(kCETV, &cetv_ciphertext)) {
@@ skipping 308 matching lines @@
       helper.ValidationComplete(QUIC_NO_ERROR, "");
       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);
-    if (proof_source_.get() &&
-        !proof_source_->GetProof(server_ip, info->sni.as_string(),
+    if (!proof_source_->GetProof(server_ip, info->sni.as_string(),
                                  requested_config->serialized,
                                  x509_ecdsa_supported, &crypto_proof->certs,
                                  &crypto_proof->signature)) {
       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);
@@ skipping 90 matching lines @@
     CryptoHandshakeMessage* out) const {
   base::AutoLock locked(configs_lock_);
   out->set_tag(kSCUP);
   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));
 
-  if (proof_source_ == nullptr) {
-    // Insecure QUIC, can send SCFG without proof.
-    return true;
-  }
-
   const vector<string>* certs;
   string signature;
   if (!proof_source_->GetProof(
           server_ip, params.sni, primary_config_->serialized,
           params.x509_ecdsa_supported, &certs, &signature)) {
     DVLOG(1) << "Server: failed to get proof.";
     return false;
   }
 
   const string compressed = CertCompressor::CompressChain(
@@ skipping 39 matching lines @@
   out->SetVector(kRREJ, info.reject_reasons);
 
   // The client may have requested a certificate chain.
   bool x509_supported = false;
   ParseProofDemand(client_hello, &x509_supported,
                    &params->x509_ecdsa_supported);
   if (!x509_supported) {
     return;
   }
 
-  if (!proof_source_.get()) {
-    return;
-  }
-
   StringPiece client_common_set_hashes;
   if (client_hello.GetStringPiece(kCCS, &client_common_set_hashes)) {
     params->client_common_set_hashes = client_common_set_hashes.as_string();
   }
 
   StringPiece client_cached_cert_hashes;
   if (client_hello.GetStringPiece(kCCRT, &client_cached_cert_hashes)) {
     params->client_cached_cert_hashes = client_cached_cert_hashes.as_string();
   }
 
@@ skipping 183 matching lines @@
         return nullptr;
       }
     }
 
     config->key_exchanges.push_back(ka.release());
   }
 
   return config;
 }
 
-void QuicCryptoServerConfig::SetProofSource(ProofSource* proof_source) {
-  proof_source_.reset(proof_source);
-}
-
 void QuicCryptoServerConfig::SetEphemeralKeySource(
     EphemeralKeySource* ephemeral_key_source) {
   ephemeral_key_source_.reset(ephemeral_key_source);
 }
 
 void QuicCryptoServerConfig::SetStrikeRegisterClient(
     StrikeRegisterClient* strike_register_client) {
   base::AutoLock locker(strike_register_client_lock_);
   DCHECK(!strike_register_client_.get());
   strike_register_client_.reset(strike_register_client);
@@ skipping 82 matching lines @@
       continue;
     }
 
     *(source_address_tokens.add_tokens()) = token;
   }
 
   return config.source_address_token_boxer->Box(
       rand, source_address_tokens.SerializeAsString());
 }
 
-bool QuicCryptoServerConfig::HasProofSource() const {
-  return proof_source_ != nullptr;
-}
-
 int QuicCryptoServerConfig::NumberOfConfigs() const {
   base::AutoLock locked(configs_lock_);
   return configs_.size();
 }
 
 HandshakeFailureReason QuicCryptoServerConfig::ParseSourceAddressToken(
     const Config& config,
     StringPiece token,
     SourceAddressTokens* tokens) const {
   string storage;
@@ skipping 149 matching lines @@
     case STRIKE_REGISTER_FAILURE:
     default:
       LOG(DFATAL) << "Unexpected server nonce error: " << nonce_error;
       return SERVER_NONCE_NOT_UNIQUE_FAILURE;
   }
 }
 
 bool QuicCryptoServerConfig::ValidateExpectedLeafCertificate(
     const CryptoHandshakeMessage& client_hello,
     const QuicCryptoProof& crypto_proof) const {
-  // If the server doesn't use https, then the client won't send XLCT and
-  // proof_source_ will be null, so in this case return true.
-  if (!proof_source_.get()) {
-    return true;
-  }
   if (crypto_proof.certs->empty()) {
     return false;
   }
 
   uint64 hash_from_client;
   if (client_hello.GetUint64(kXLCT, &hash_from_client) != QUIC_NO_ERROR) {
     return false;
   }
   return CryptoUtils::ComputeLeafCertHash(crypto_proof.certs->at(0)) ==
          hash_from_client;
 }
 
 void QuicCryptoServerConfig::ParseProofDemand(
     const CryptoHandshakeMessage& client_hello,
     bool* x509_supported,
     bool* x509_ecdsa_supported) const {
   const QuicTag* their_proof_demands;
   size_t num_their_proof_demands;
 
-  if (proof_source_.get() == nullptr ||
-      client_hello.GetTaglist(kPDMD, &their_proof_demands,
+  if (client_hello.GetTaglist(kPDMD, &their_proof_demands,
                               &num_their_proof_demands) != QUIC_NO_ERROR) {
     return;
   }
 
   *x509_supported = false;
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     switch (their_proof_demands[i]) {
       case kX509:
         *x509_supported = true;
         *x509_ecdsa_supported = true;
         break;
       case kX59R:
         *x509_supported = true;
         break;
     }
   }
 }
 
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0),
       source_address_token_boxer(nullptr) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net