[refactor] Misc post-NSS WebCrypto cleanups.

components/webcrypto/algorithms/hmac.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 <openssl/hmac.h>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "components/webcrypto/algorithm_implementation.h"
 #include "components/webcrypto/algorithms/secret_key_util.h"
 #include "components/webcrypto/algorithms/util_openssl.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/key.h"
 #include "components/webcrypto/status.h"
 #include "components/webcrypto/webcrypto_util.h"
 #include "crypto/openssl_util.h"
 #include "crypto/secure_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
 namespace {
 
-// TODO(eroman): Use EVP_MD_block_size() instead.
-Status GetShaBlockSizeBits(const blink::WebCryptoAlgorithm& algorithm,
-                           unsigned int* block_size_bits) {
-  switch (algorithm.id()) {
-    case blink::WebCryptoAlgorithmIdSha1:
-    case blink::WebCryptoAlgorithmIdSha256:
-      *block_size_bits = 512;
-      return Status::Success();
-    case blink::WebCryptoAlgorithmIdSha384:
-    case blink::WebCryptoAlgorithmIdSha512:
-      *block_size_bits = 1024;
-      return Status::Success();
-    default:
-      return Status::ErrorUnsupported();
-  }
+Status GetDigestBlockSizeBits(const blink::WebCryptoAlgorithm& algorithm,
+                              unsigned int* block_size_bits) {
+  const EVP_MD* md = GetDigest(algorithm.id());
+  if (!md)
+    return Status::ErrorUnsupported();
+  *block_size_bits = static_cast<unsigned int>(8 * EVP_MD_block_size(md));
+  return Status::Success();
 }
 
 // Gets the requested key length in bits for an HMAC import operation.
 Status GetHmacImportKeyLengthBits(
     const blink::WebCryptoHmacImportParams* params,
     unsigned int key_data_byte_length,
     unsigned int* keylen_bits) {
   if (key_data_byte_length == 0)
     return Status::ErrorHmacImportEmptyKey();
 
@@ skipping 79 matching lines @@
     const blink::WebCryptoHmacKeyGenParams* params =
         algorithm.hmacKeyGenParams();
 
     unsigned int keylen_bits = 0;
     if (params->hasLengthBits()) {
       keylen_bits = params->optionalLengthBits();
       // Zero-length HMAC keys are disallowed by the spec.
       if (keylen_bits == 0)
         return Status::ErrorGenerateHmacKeyLengthZero();
     } else {
-      status = GetShaBlockSizeBits(params->hash(), &keylen_bits);
+      status = GetDigestBlockSizeBits(params->hash(), &keylen_bits);
       if (status.IsError())
         return status;
     }
 
     return GenerateWebCryptoSecretKey(blink::WebCryptoKeyAlgorithm::createHmac(
                                           params->hash().id(), keylen_bits),
                                       extractable, usages, keylen_bits, result);
   }
 
   Status VerifyKeyUsagesBeforeImportKey(
@@ skipping 132 matching lines @@
         key_length_algorithm.hmacImportParams();
 
     *has_length_bits = true;
     if (params->hasLengthBits()) {
       *length_bits = params->optionalLengthBits();
       if (*length_bits == 0)
         return Status::ErrorGetHmacKeyLengthZero();
       return Status::Success();
     }
 
-    return GetShaBlockSizeBits(params->hash(), length_bits);
+    return GetDigestBlockSizeBits(params->hash(), length_bits);
   }
 };
 
 }  // namespace
 
 scoped_ptr<AlgorithmImplementation> CreateHmacImplementation() {
   return make_scoped_ptr(new HmacImplementation);
 }
 
 }  // namespace webcrypto