Switch SignatureVerifier to taking an algorithm enum.

crypto/signature_verifier_nss.cc

 // Copyright (c) 2011 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 "crypto/signature_verifier.h"
 
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <secerr.h>
@@ skipping 12 matching lines @@
 HASH_HashType ToNSSHashType(SignatureVerifier::HashAlgorithm hash_alg) {
   switch (hash_alg) {
     case SignatureVerifier::SHA1:
       return HASH_AlgSHA1;
     case SignatureVerifier::SHA256:
       return HASH_AlgSHA256;
   }
   return HASH_AlgNULL;
 }
 
+SECOidTag ToNSSSignatureType(SignatureVerifier::SignatureAlgorithm sig_alg) {
+  switch (sig_alg) {
+    case SignatureVerifier::RSA_PKCS1_SHA1:
+      return SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION;
+    case SignatureVerifier::RSA_PKCS1_SHA256:
+      return SEC_OID_PKCS1_SHA256_WITH_RSA_ENCRYPTION;
+    case SignatureVerifier::ECDSA_SHA256:
+      return SEC_OID_ANSIX962_ECDSA_SHA256_SIGNATURE;
+  }
+  return SEC_OID_UNKNOWN;
+}
+
 SECStatus VerifyRSAPSS_End(SECKEYPublicKey* public_key,
                            HASHContext* hash_context,
                            HASH_HashType mask_hash_alg,
                            unsigned int salt_len,
                            const unsigned char* signature,
                            unsigned int signature_len) {
   unsigned int hash_len = HASH_ResultLenContext(hash_context);
   std::vector<unsigned char> hash(hash_len);
   HASH_End(hash_context, &hash[0], &hash_len, hash.size());
 
@@ skipping 24 matching lines @@
       salt_len_(0),
       public_key_(NULL),
       hash_context_(NULL) {
   EnsureNSSInit();
 }
 
 SignatureVerifier::~SignatureVerifier() {
   Reset();
 }
 
-bool SignatureVerifier::VerifyInit(const uint8_t* signature_algorithm,
-                                   int signature_algorithm_len,
+bool SignatureVerifier::VerifyInit(SignatureAlgorithm signature_algorithm,
                                    const uint8_t* signature,
                                    int signature_len,
                                    const uint8_t* public_key_info,
                                    int public_key_info_len) {
   if (vfy_context_ || hash_context_)
     return false;
 
   signature_.assign(signature, signature + signature_len);
 
   SECKEYPublicKey* public_key = DecodePublicKeyInfo(public_key_info,
                                                     public_key_info_len);
   if (!public_key)
     return false;
 
-  PLArenaPool* arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
-  if (!arena) {
-    SECKEY_DestroyPublicKey(public_key);
-    return false;
-  }
-
-  SECItem sig_alg_der;
-  sig_alg_der.type = siBuffer;
-  sig_alg_der.data = const_cast<uint8_t*>(signature_algorithm);
-  sig_alg_der.len = signature_algorithm_len;
-  SECAlgorithmID sig_alg_id;
-  SECStatus rv;
-  rv = SEC_QuickDERDecodeItem(arena, &sig_alg_id,
-                              SEC_ASN1_GET(SECOID_AlgorithmIDTemplate),
-                              &sig_alg_der);
-  if (rv != SECSuccess) {
-    SECKEY_DestroyPublicKey(public_key);
-    PORT_FreeArena(arena, PR_TRUE);
-    return false;
-  }
-
   SECItem sig;
   sig.type = siBuffer;
   sig.data = const_cast<uint8_t*>(signature);
   sig.len = signature_len;
-  SECOidTag hash_alg_tag;
-  vfy_context_ = VFY_CreateContextWithAlgorithmID(public_key, &sig,
-                                                  &sig_alg_id, &hash_alg_tag,
-                                                  NULL);
+  vfy_context_ = VFY_CreateContext(
+      public_key, &sig, ToNSSSignatureType(signature_algorithm), nullptr);
   SECKEY_DestroyPublicKey(public_key);  // Done with public_key.
-  PORT_FreeArena(arena, PR_TRUE);  // Done with sig_alg_id.
   if (!vfy_context_) {
     // A corrupted RSA signature could be detected without the data, so
     // VFY_CreateContextWithAlgorithmID may fail with SEC_ERROR_BAD_SIGNATURE
     // (-8182).
     return false;
   }
 
-  rv = VFY_Begin(vfy_context_);
-  if (rv != SECSuccess) {
+  if (VFY_Begin(vfy_context_) != SECSuccess) {
     NOTREACHED();
     return false;
   }
   return true;
 }
 
 bool SignatureVerifier::VerifyInitRSAPSS(HashAlgorithm hash_alg,
                                          HashAlgorithm mask_hash_alg,
                                          int salt_len,
                                          const uint8_t* signature,
@@ skipping 75 matching lines @@
     hash_context_ = NULL;
   }
   if (public_key_) {
     SECKEY_DestroyPublicKey(public_key_);
     public_key_ = NULL;
   }
   signature_.clear();
 }
 
 }  // namespace crypto