Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

net/quic/chromium/crypto/proof_source_chromium.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/chromium/crypto/proof_source_chromium.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "crypto/openssl_util.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "third_party/boringssl/src/include/openssl/digest.h"
@@ skipping 67 matching lines @@
 }
 
 bool ProofSourceChromium::GetProof(
     const IPAddress& server_ip,
     const string& hostname,
     const string& server_config,
     QuicVersion quic_version,
     base::StringPiece chlo_hash,
     const QuicTagVector& /* connection_options */,
     scoped_refptr<ProofSource::Chain>* out_chain,
-    string* out_signature,
-    string* out_leaf_cert_sct) {
+    QuicCryptoProof* proof) {
+  DCHECK(proof != nullptr);
   DCHECK(private_key_.get()) << " this: " << this;
 
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
   bssl::ScopedEVP_MD_CTX sign_context;
   EVP_PKEY_CTX* pkey_ctx;
 
   uint32_t len_tmp = chlo_hash.length();
   if (!EVP_DigestSignInit(sign_context.get(), &pkey_ctx, EVP_sha256(), nullptr,
                           private_key_->key()) ||
       !EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) ||
@@ skipping 18 matching lines @@
   size_t len = 0;
   if (!EVP_DigestSignFinal(sign_context.get(), nullptr, &len)) {
     return false;
   }
   std::vector<uint8_t> signature(len);
   // Sign it.
   if (!EVP_DigestSignFinal(sign_context.get(), signature.data(), &len)) {
     return false;
   }
   signature.resize(len);
-  out_signature->assign(reinterpret_cast<const char*>(signature.data()),
-                        signature.size());
+  proof->signature.assign(reinterpret_cast<const char*>(signature.data()),
+                          signature.size());
   *out_chain = chain_;
   VLOG(1) << "signature: "
-          << base::HexEncode(out_signature->data(), out_signature->size());
-  *out_leaf_cert_sct = signed_certificate_timestamp_;
+          << base::HexEncode(proof->signature.data(), proof->signature.size());
+  proof->leaf_cert_scts = signed_certificate_timestamp_;
   return true;
 }
 
 void ProofSourceChromium::GetProof(const IPAddress& server_ip,
                                    const std::string& hostname,
                                    const std::string& server_config,
                                    QuicVersion quic_version,
                                    base::StringPiece chlo_hash,
                                    const QuicTagVector& connection_options,
                                    std::unique_ptr<Callback> callback) {
   // As a transitional implementation, just call the synchronous version of
   // GetProof, then invoke the callback with the results and destroy it.
   scoped_refptr<ProofSource::Chain> chain;
   string signature;
   string leaf_cert_sct;
-  const bool ok =
-      GetProof(server_ip, hostname, server_config, quic_version, chlo_hash,
-               connection_options, &chain, &signature, &leaf_cert_sct);
-  callback->Run(ok, chain, signature, leaf_cert_sct, nullptr /* details */);
+  QuicCryptoProof out_proof;
+  const bool ok = GetProof(server_ip, hostname, server_config, quic_version,
+                           chlo_hash, connection_options, &chain, &out_proof);
+  callback->Run(ok, chain, out_proof, nullptr /* details */);
 }
 
 }  // namespace net