Switch SignatureVerifier to taking an algorithm enum.

components/update_client/client_update_protocol_ecdsa.cc

 // Copyright 2016 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 "components/update_client/client_update_protocol_ecdsa.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/random.h"
 #include "crypto/sha2.h"
 #include "crypto/signature_verifier.h"
 
 namespace update_client {
 
 namespace {
 
-// This is the algorithm ID for ECDSA with SHA-256. Parameters are ABSENT.
-// RFC 5758:
-//   ecdsa-with-SHA256 OBJECT IDENTIFIER ::= { iso(1) member-body(2)
-//        us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) 2 }
-//   ...
-//   When the ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-SHA384, or
-//   ecdsa-with-SHA512 algorithm identifier appears in the algorithm field
-//   as an AlgorithmIdentifier, the encoding MUST omit the parameters
-//   field.  That is, the AlgorithmIdentifier SHALL be a SEQUENCE of one
-//   component, the OID ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with-
-//   SHA384, or ecdsa-with-SHA512.
-// See also RFC 5480, Appendix A.
-static const uint8_t kECDSAWithSHA256AlgorithmID[] = {
-    0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02,
-};
-
 std::vector<uint8_t> SHA256HashStr(const base::StringPiece& str) {
   std::vector<uint8_t> result(crypto::kSHA256Length);
   crypto::SHA256HashString(str, &result.front(), result.size());
   return result;
 }
 
 std::vector<uint8_t> SHA256HashVec(const std::vector<uint8_t>& vec) {
   if (vec.empty())
     return SHA256HashStr(base::StringPiece());
 
@@ skipping 134 matching lines @@
                         response_hash.end());
   signed_message.insert(signed_message.end(), request_query_cup2key_.begin(),
                         request_query_cup2key_.end());
 
   const std::vector<uint8_t> signed_message_hash =
       SHA256HashVec(signed_message);
 
   // Initialize the signature verifier.
   crypto::SignatureVerifier verifier;
   if (!verifier.VerifyInit(
-          kECDSAWithSHA256AlgorithmID, sizeof(kECDSAWithSHA256AlgorithmID),
-          &signature.front(), static_cast<int>(signature.size()),
-          &public_key_.front(), static_cast<int>(public_key_.size()))) {
+          crypto::SignatureVerifier::ECDSA_SHA256, &signature.front(),
+          static_cast<int>(signature.size()), &public_key_.front(),
+          static_cast<int>(public_key_.size()))) {
     DVLOG(1) << "Couldn't init SignatureVerifier.";
     return false;
   }
 
   // If the verification fails, that implies one of two outcomes:
   // * The signature was modified
   // * The buffer that the server signed does not match the buffer that the
   //   client assembled -- implying that either request body or response body
   //   was modified, or a different nonce value was used.
   verifier.VerifyUpdate(&signed_message_hash.front(),
                         static_cast<int>(signed_message_hash.size()));
   return verifier.VerifyFinal();
 }
 
 }  // namespace update_client