Revert 198736 "Land Recent QUIC changes"

trunk/src/net/quic/crypto/crypto_server_config.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_server_config.h"
 
 #include "base/stl_util.h"
 #include "crypto/hkdf.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/crypto/aes_128_gcm_decrypter.h"
 #include "net/quic/crypto/aes_128_gcm_encrypter.h"
-#include "net/quic/crypto/cert_compressor.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.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_source.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/crypto/source_address_token.h"
 #include "net/quic/crypto/strike_register.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_protocol.h"
-#include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using crypto::SecureHash;
 using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
 // static
@@ skipping 322 matching lines @@
           StringPiece(reinterpret_cast<const char*>(config->orbit),
                       sizeof(config->orbit)),
           &params->server_nonce);
     }
     out->SetStringPiece(kNONC, params->server_nonce);
 
     // The client may have requested a certificate chain.
     const CryptoTag* their_proof_demands;
     size_t num_their_proof_demands;
 
-    if (proof_source_.get() != NULL &&
+    if (valid_source_address_token &&
+        proof_source_.get() != NULL &&
         !sni.empty() &&
         client_hello.GetTaglist(kPDMD, &their_proof_demands,
                                 &num_their_proof_demands) == QUIC_NO_ERROR) {
       for (size_t i = 0; i < num_their_proof_demands; i++) {
         if (their_proof_demands[i] != kX509) {
           continue;
         }
 
+        // TODO(agl): in the future we will hopefully have a cached-info like
+        // mechanism where we can omit certificates that the client already has.
+        // In that case, the certificate chain may be small enough to include
+        // without a source-address token. But, for now, we always send the full
+        // chain and we always need a valid source-address token.
+
         const vector<string>* certs;
         string signature;
         if (!proof_source_->GetProof(sni.as_string(), config->serialized,
                                      &certs, &signature)) {
           break;
         }
 
-        StringPiece their_common_set_hashes;
-        StringPiece their_cached_cert_hashes;
-        client_hello.GetStringPiece(kCCS, &their_common_set_hashes);
-        client_hello.GetStringPiece(kCCRT, &their_cached_cert_hashes);
+        // TODO(agl): compress and omit certificates where possible based on
+        // the client's cached certificates.
+        size_t cert_bytes = 0;
+        for (vector<string>::const_iterator i = certs->begin();
+             i != certs->end(); ++i) {
+          cert_bytes += i->size();
+        }
+        // There's a three byte length-prefix for each certificate.
+        cert_bytes += certs->size()*3;
+        scoped_ptr<char[]> buf(new char[cert_bytes]);
 
-        const string compressed = CertCompressor::CompressChain(
-            *certs, their_common_set_hashes, their_cached_cert_hashes,
-            config->common_cert_set_.get());
+        size_t j = 0;
+        for (vector<string>::const_iterator i = certs->begin();
+             i != certs->end(); ++i) {
+          size_t len = i->size();
+          buf[j++] = len;
+          buf[j++] = len >> 8;
+          buf[j++] = len >> 16;
+          memcpy(&buf[j], i->data(), i->size());
+          j += i->size();
+        }
 
-        // kMaxUnverifiedSize is the number of bytes that the certificate chain
-        // and signature can consume before we will demand a valid
-        // source-address token.
-        static const size_t kMaxUnverifiedSize = 400;
-        if (valid_source_address_token ||
-            signature.size() + compressed.size() < kMaxUnverifiedSize) {
-          out->SetStringPiece(kCERT, compressed);
-          out->SetStringPiece(kPROF, signature);
-        }
+        DCHECK_EQ(j, cert_bytes);
+
+        out->SetStringPiece(kCERT, StringPiece(buf.get(), cert_bytes));
+        out->SetStringPiece(kPROF, signature);
         break;
       }
     }
 
     return QUIC_NO_ERROR;
   }
 
   const CryptoTag* their_aeads;
   const CryptoTag* their_key_exchanges;
   size_t num_their_aeads, num_their_key_exchanges;
@@ skipping 150 matching lines @@
 }
 
 QuicCryptoServerConfig::Config::Config() {
 }
 
 QuicCryptoServerConfig::Config::~Config() {
   STLDeleteElements(&key_exchanges);
 }
 
 }  // namespace net