Add support to QUIC for QUIC_VERSION_8: for RSA-PSS signatures, set

net/quic/crypto/proof_verifier_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/crypto/proof_verifier_chromium.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 24 matching lines @@
   : cert_verifier_(cert_verifier),
     next_state_(STATE_NONE),
     net_log_(net_log) {
 }
 
 ProofVerifierChromium::~ProofVerifierChromium() {
   verifier_.reset();
 }
 
 ProofVerifierChromium::Status ProofVerifierChromium::VerifyProof(
+    QuicVersion version,
     const string& hostname,
     const string& server_config,
     const vector<string>& certs,
     const string& signature,
     std::string* error_details,
     scoped_ptr<ProofVerifyDetails>* details,
     ProofVerifierCallback* callback) {
   DCHECK(error_details);
   DCHECK(details);
   DCHECK(callback);
@@ skipping 27 matching lines @@
   if (!cert_.get()) {
     *error_details = "Failed to create certificate chain";
     DLOG(WARNING) << *error_details;
     verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID;
     details->reset(verify_details_.release());
     return FAILURE;
   }
 
   // We call VerifySignature first to avoid copying of server_config and
   // signature.
-  if (!VerifySignature(server_config, signature, certs[0])) {
+  if (!VerifySignature(version, server_config, signature, certs[0])) {
     *error_details = "Failed to verify signature of server config";
     DLOG(WARNING) << *error_details;
     verify_details_->cert_verify_result.cert_status = CERT_STATUS_INVALID;
     details->reset(verify_details_.release());
     return FAILURE;
   }
 
   hostname_ = hostname;
 
   next_state_ = STATE_VERIFY_CERT;
@@ skipping 66 matching lines @@
                                   ErrorToString(result));
     DLOG(WARNING) << error_details_;
     result = ERR_FAILED;
   }
 
   // Exit DoLoop and return the result to the caller to VerifyProof.
   DCHECK_EQ(STATE_NONE, next_state_);
   return result;
 }
 
-bool ProofVerifierChromium::VerifySignature(const string& signed_data,
+bool ProofVerifierChromium::VerifySignature(QuicVersion version,
+                                            const string& signed_data,
                                             const string& signature,
                                             const string& cert) {
   StringPiece spki;
   if (!asn1::ExtractSPKIFromDERCert(cert, &spki)) {
     DLOG(WARNING) << "ExtractSPKIFromDERCert failed";
     return false;
   }
 
   crypto::SignatureVerifier verifier;
 
   size_t size_bits;
   X509Certificate::PublicKeyType type;
   X509Certificate::GetPublicKeyInfo(cert_->os_cert_handle(), &size_bits,
                                     &type);
   if (type == X509Certificate::kPublicKeyTypeRSA) {
     crypto::SignatureVerifier::HashAlgorithm hash_alg =
         crypto::SignatureVerifier::SHA256;
     crypto::SignatureVerifier::HashAlgorithm mask_hash_alg = hash_alg;
     unsigned int hash_len = 32;  // 32 is the length of a SHA-256 hash.
-    // TODO(wtc): change this to hash_len when we can change the wire format.
-    unsigned int salt_len = signature.size() - hash_len - 2;
+    unsigned int salt_len =
+        version >= QUIC_VERSION_8 ? hash_len : signature.size() - hash_len - 2;

[wtc, 2013/08/08 00:37:33]

This is the most important change, which selects the salt length based on the
Quic version.

 
     bool ok = verifier.VerifyInitRSAPSS(
         hash_alg, mask_hash_alg, salt_len,
         reinterpret_cast<const uint8*>(signature.data()), signature.size(),
         reinterpret_cast<const uint8*>(spki.data()), spki.size());
     if (!ok) {
       DLOG(WARNING) << "VerifyInitRSAPSS failed";
       return false;
     }
   } else if (type == X509Certificate::kPublicKeyTypeECDSA) {
@@ skipping 37 matching lines @@
   if (!verifier.VerifyFinal()) {
     DLOG(WARNING) << "VerifyFinal failed";
     return false;
   }
 
   DLOG(INFO) << "VerifyFinal success";
   return true;
 }
 
 }  // namespace net