Land Recent QUIC changes

net/quic/crypto/crypto_handshake.cc

 // Copyright (c) 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/crypto_handshake.h"
 
 #include <ctype.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "crypto/secure_hash.h"
 #include "net/base/net_util.h"
+#include "net/quic/crypto/cert_compressor.h"
+#include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/curve25519_key_exchange.h"
 #include "net/quic/crypto/key_exchange.h"
 #include "net/quic/crypto/p256_key_exchange.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
 CryptoHandshakeMessage::CryptoHandshakeMessage() : tag_(0) {}
 
@@ skipping 62 matching lines @@
 }
 
 void CryptoHandshakeMessage::SetStringPiece(CryptoTag tag, StringPiece value) {
   tag_value_map_[tag] = value.as_string();
 }
 
 QuicErrorCode CryptoHandshakeMessage::GetTaglist(CryptoTag tag,
                                                  const CryptoTag** out_tags,
                                                  size_t* out_len) const {
   CryptoTagValueMap::const_iterator it = tag_value_map_.find(tag);
+  *out_len = 0;
   QuicErrorCode ret = QUIC_NO_ERROR;
 
   if (it == tag_value_map_.end()) {
     ret = QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   } else if (it->second.size() % sizeof(CryptoTag) != 0) {
     ret = QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
   if (ret != QUIC_NO_ERROR) {
     *out_tags = NULL;
@@ skipping 192 matching lines @@
 }
 
 QuicCryptoNegotiatedParameters::~QuicCryptoNegotiatedParameters() {
 }
 
 
 // static
 const char QuicCryptoConfig::kLabel[] = "QUIC key expansion";
 
 QuicCryptoConfig::QuicCryptoConfig()
-    : version(0) {
+    : version(0),
+      common_cert_set_(new CommonCertSetQUIC) {
 }
 
 QuicCryptoConfig::~QuicCryptoConfig() {}
 
 QuicCryptoClientConfig::QuicCryptoClientConfig() {}
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   STLDeleteValues(&cached_states_);
 }
 
@@ skipping 23 matching lines @@
     StringPiece scfg) {
   scfg_.reset(CryptoFramer::ParseMessage(scfg));
   if (!scfg_.get()) {
     return false;
   }
   server_config_ = scfg.as_string();
   return true;
 }
 
 void QuicCryptoClientConfig::CachedState::SetProof(
-    const vector<StringPiece>& certs, StringPiece signature) {
+    const vector<string>& certs, StringPiece signature) {
   bool has_changed = signature != server_config_sig_;
 
-  if (certs.size() != certs_.size()) {
+  if (certs_.size() != certs.size()) {
     has_changed = true;
   }
   if (!has_changed) {
     for (size_t i = 0; i < certs_.size(); i++) {
-      if (certs[i] != certs_[i]) {
+      if (certs_[i] != certs[i]) {
         has_changed = true;
         break;
       }
     }
   }
 
   if (!has_changed) {
     return;
   }
 
   // If the proof has changed then it needs to be revalidated.
   server_config_valid_ = false;
-  certs_.clear();
-  for (vector<StringPiece>::const_iterator i = certs.begin();
-       i != certs.end(); ++i) {
-    certs_.push_back(i->as_string());
-  }
+  certs_ = certs;
   server_config_sig_ = signature.as_string();
 }
 
 void QuicCryptoClientConfig::CachedState::SetProofValid() {
   server_config_valid_ = true;
 }
 
 const string&
 QuicCryptoClientConfig::CachedState::server_config() const {
   return server_config_;
@@ skipping 44 matching lines @@
   }
 
   CachedState* cached = new CachedState;
   cached_states_.insert(make_pair(server_hostname, cached));
   return cached;
 }
 
 void QuicCryptoClientConfig::FillInchoateClientHello(
     const string& server_hostname,
     const CachedState* cached,
+    QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kCHLO);
 
   // Server name indication.
   // If server_hostname is not an IP address literal, it is a DNS hostname.
   IPAddressNumber ip;
   if (!server_hostname.empty() &&
       !ParseIPLiteralToNumber(server_hostname, &ip)) {
     out->SetStringPiece(kSNI, server_hostname);
   }
   out->SetValue(kVERS, version);
 
   if (!cached->source_address_token().empty()) {
     out->SetStringPiece(kSRCT, cached->source_address_token());
   }
 
   out->SetTaglist(kPDMD, kX509, 0);
+
+  if (common_cert_set_.get()) {
+    out->SetStringPiece(kCCS, common_cert_set_->GetCommonHashes());
+  }
+
+  const vector<string>& certs = cached->certs();
+  if (!certs.empty()) {
+    vector<uint64> hashes;
+    hashes.reserve(certs.size());
+    for (vector<string>::const_iterator i = certs.begin();
+         i != certs.end(); ++i) {
+      hashes.push_back(QuicUtils::FNV1a_64_Hash(i->data(), i->size()));
+    }
+    out->SetVector(kCCRT, hashes);
+    // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
+    // client config is being used for multiple connections, another connection
+    // doesn't update the cached certificates and cause us to be unable to
+    // process the server's compressed certificate chain.
+    out_params->cached_certs = certs;
+  }
 }
 
 QuicErrorCode QuicCryptoClientConfig::FillClientHello(
     const string& server_hostname,
     QuicGuid guid,
     const CachedState* cached,
     const QuicClock* clock,
     QuicRandom* rand,
     QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out,
     string* error_details) const {
   DCHECK(error_details != NULL);
 
-  FillInchoateClientHello(server_hostname, cached, out);
+  FillInchoateClientHello(server_hostname, cached, out_params, out);
 
   const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
   if (!scfg) {
     // This should never happen as our caller should have checked
     // cached->is_complete() before calling this function.
     *error_details = "Handshake not ready";
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
   StringPiece scid;
@@ skipping 118 matching lines @@
 
   StringPiece nonce;
   if (rej.GetStringPiece(kNONC, &nonce) &&
       nonce.size() == kNonceSize) {
     out_params->server_nonce = nonce.as_string();
   }
 
   StringPiece proof, cert_bytes;
   if (rej.GetStringPiece(kPROF, &proof) &&
       rej.GetStringPiece(kCERT, &cert_bytes)) {
-    vector<StringPiece> certs;
-    while (!cert_bytes.empty()) {
-      if (cert_bytes.size() < 3) {
-        *error_details = "Certificate length truncated";
-        return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
-      }
-      size_t len = static_cast<size_t>(cert_bytes[0]) |
-                   static_cast<size_t>(cert_bytes[1]) << 8 |
-                   static_cast<size_t>(cert_bytes[2]) << 16;
-      if (len == 0) {
-        *error_details = "Zero length certificate";
-        return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
-      }
-      cert_bytes.remove_prefix(3);
-      if (cert_bytes.size() < len) {
-        *error_details = "Certificate truncated";
-        return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
-      }
-      certs.push_back(StringPiece(cert_bytes.data(), len));
-      cert_bytes.remove_prefix(len);
+    vector<string> certs;
+    if (!CertCompressor::DecompressChain(cert_bytes, out_params->cached_certs,
+                                         common_cert_set_.get(), &certs)) {
+      *error_details = "Certificate data invalid";
+      return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
     cached->SetProof(certs, proof);
   }
 
   return QUIC_NO_ERROR;
 }
 
 QuicErrorCode QuicCryptoClientConfig::ProcessServerHello(
     const CryptoHandshakeMessage& server_hello,
@@ skipping 16 matching lines @@
 
 const ProofVerifier* QuicCryptoClientConfig::proof_verifier() const {
   return proof_verifier_.get();
 }
 
 void QuicCryptoClientConfig::SetProofVerifier(ProofVerifier* verifier) {
   proof_verifier_.reset(verifier);
 }
 
 }  // namespace net