Switch SignatureVerifier to taking an algorithm enum.

extensions/browser/verified_contents.cc

 // Copyright 2014 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 "extensions/browser/verified_contents.h"
 
 #include <stddef.h>
 
 #include "base/base64url.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/crx_file/id_util.h"
 #include "crypto/signature_verifier.h"
 #include "extensions/common/extension.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 
 namespace {
 
-// Note: this structure is an ASN.1 which encodes the algorithm used with its
-// parameters.  The signature algorithm is "RSA256" aka "RSASSA-PKCS-v1_5 using
-// SHA-256 hash algorithm". This is defined in PKCS #1 (RFC 3447).
-// It is encoding: { OID sha256WithRSAEncryption      PARAMETERS NULL }
-const uint8_t kSignatureAlgorithm[15] = {0x30, 0x0d, 0x06, 0x09, 0x2a,
-                                         0x86, 0x48, 0x86, 0xf7, 0x0d,
-                                         0x01, 0x01, 0x0b, 0x05, 0x00};
-
 const char kBlockSizeKey[] = "block_size";
 const char kContentHashesKey[] = "content_hashes";
 const char kDescriptionKey[] = "description";
 const char kFilesKey[] = "files";
 const char kFormatKey[] = "format";
 const char kHashBlockSizeKey[] = "hash_block_size";
 const char kHeaderKidKey[] = "header.kid";
 const char kItemIdKey[] = "item_id";
 const char kItemVersionKey[] = "item_version";
 const char kPathKey[] = "path";
@@ skipping 259 matching lines @@
     return false;
 
   return true;
 }
 
 bool VerifiedContents::VerifySignature(const std::string& protected_value,
                                        const std::string& payload,
                                        const std::string& signature_bytes) {
   crypto::SignatureVerifier signature_verifier;
   if (!signature_verifier.VerifyInit(
-          kSignatureAlgorithm, sizeof(kSignatureAlgorithm),
+          crypto::SignatureVerifier::RSA_PKCS1_SHA256,
           reinterpret_cast<const uint8_t*>(signature_bytes.data()),
           signature_bytes.size(), public_key_, public_key_size_)) {
     VLOG(1) << "Could not verify signature - VerifyInit failure";
     return false;
   }
 
   signature_verifier.VerifyUpdate(
       reinterpret_cast<const uint8_t*>(protected_value.data()),
       protected_value.size());
 
   std::string dot(".");
   signature_verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(dot.data()),
                                   dot.size());
 
   signature_verifier.VerifyUpdate(
       reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions