Remove some duplicated code for getting the EVP_MP.

content/renderer/webcrypto/platform_crypto_openssl.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 "content/renderer/webcrypto/platform_crypto.h"
 
 #include <vector>
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
@@ skipping 40 matching lines @@
       return EVP_aes_128_cbc();
     case 24:
       return EVP_aes_192_cbc();
     case 32:
       return EVP_aes_256_cbc();
     default:
       return NULL;
   }
 }
 
+const EVP_MD* GetDigest(blink::WebCryptoAlgorithmId id) {
+  switch (id) {
+    case blink::WebCryptoAlgorithmIdSha1:
+      return EVP_sha1();
+    case blink::WebCryptoAlgorithmIdSha224:
+      return EVP_sha224();
+    case blink::WebCryptoAlgorithmIdSha256:
+      return EVP_sha256();
+    case blink::WebCryptoAlgorithmIdSha384:
+      return EVP_sha384();
+    case blink::WebCryptoAlgorithmIdSha512:
+      return EVP_sha512();
+    default:
+      return NULL;
+  }
+}
+
 // OpenSSL constants for EVP_CipherInit_ex(), do not change
 enum CipherOperation { kDoDecrypt = 0, kDoEncrypt = 1 };
 
 Status AesCbcEncryptDecrypt(EncryptOrDecrypt mode,
                             SymKey* key,
                             const CryptoData& iv,
                             const CryptoData& data,
                             blink::WebArrayBuffer* buffer) {
   CipherOperation cipher_operation =
       (mode == ENCRYPT) ? kDoEncrypt : kDoDecrypt;
@@ skipping 77 matching lines @@
                             blink::WebArrayBuffer* buffer) {
   // TODO(eroman): inline the function here.
   return AesCbcEncryptDecrypt(mode, key, iv, data, buffer);
 }
 
 Status DigestSha(blink::WebCryptoAlgorithmId algorithm,
                  const CryptoData& data,
                  blink::WebArrayBuffer* buffer) {
   crypto::OpenSSLErrStackTracer(FROM_HERE);
 
-  const EVP_MD* digest_algorithm;
-  switch (algorithm) {
-    case blink::WebCryptoAlgorithmIdSha1:
-      digest_algorithm = EVP_sha1();
-      break;
-    case blink::WebCryptoAlgorithmIdSha224:
-      digest_algorithm = EVP_sha224();
-      break;
-    case blink::WebCryptoAlgorithmIdSha256:
-      digest_algorithm = EVP_sha256();
-      break;
-    case blink::WebCryptoAlgorithmIdSha384:
-      digest_algorithm = EVP_sha384();
-      break;
-    case blink::WebCryptoAlgorithmIdSha512:
-      digest_algorithm = EVP_sha512();
-      break;
-    default:
-      // Not a SHA algorithm.
-      return Status::ErrorUnexpected();
-  }
+  const EVP_MD* digest_algorithm = GetDigest(algorithm);
+  if (!digest_algorithm)
+    return Status::ErrorUnexpected();
 
   crypto::ScopedOpenSSL<EVP_MD_CTX, EVP_MD_CTX_destroy> digest_context(
       EVP_MD_CTX_create());
   if (!digest_context.get())
     return Status::Error();
 
   if (!EVP_DigestInit_ex(digest_context.get(), digest_algorithm, NULL) ||
       !EVP_DigestUpdate(
           digest_context.get(), data.bytes(), data.byte_length())) {
     return Status::Error();
@@ skipping 65 matching lines @@
 
   return Status::Success();
 }
 
 Status SignHmac(SymKey* key,
                 const blink::WebCryptoAlgorithm& hash,
                 const CryptoData& data,
                 blink::WebArrayBuffer* buffer) {
   blink::WebArrayBuffer result;
 
-  const EVP_MD* evp_sha = 0;
-  unsigned int hmac_expected_length = 0;
-  // Note that HMAC length is determined by the hash used.
-  switch (hash.id()) {
-    case blink::WebCryptoAlgorithmIdSha1:
-      evp_sha = EVP_sha1();
-      hmac_expected_length = SHA_DIGEST_LENGTH;
-      break;
-    case blink::WebCryptoAlgorithmIdSha224:
-      evp_sha = EVP_sha224();
-      hmac_expected_length = SHA224_DIGEST_LENGTH;
-      break;
-    case blink::WebCryptoAlgorithmIdSha256:
-      evp_sha = EVP_sha256();
-      hmac_expected_length = SHA256_DIGEST_LENGTH;
-      break;
-    case blink::WebCryptoAlgorithmIdSha384:
-      evp_sha = EVP_sha384();
-      hmac_expected_length = SHA384_DIGEST_LENGTH;
-      break;
-    case blink::WebCryptoAlgorithmIdSha512:
-      evp_sha = EVP_sha512();
-      hmac_expected_length = SHA512_DIGEST_LENGTH;
-      break;
-    default:
-      // Not a digest algorithm.
-      return Status::ErrorUnsupported();
-  }
+  const EVP_MD* digest_algorithm = GetDigest(hash.id());
+  if (!digest_algorithm)
+    return Status::ErrorUnsupported();
+  unsigned int hmac_expected_length = EVP_MD_size(digest_algorithm);
 
   const std::vector<unsigned char>& raw_key = key->key();
 
   // OpenSSL wierdness here.
   // First, HMAC() needs a void* for the key data, so make one up front as a
   // cosmetic to avoid a cast. Second, OpenSSL does not like a NULL key,
   // which will result if the raw_key vector is empty; an entirely valid
   // case. Handle this specific case by pointing to an empty array.
   const unsigned char null_key[] = {};
   const void* const raw_key_voidp = raw_key.size() ? &raw_key[0] : null_key;
 
   result = blink::WebArrayBuffer::create(hmac_expected_length, 1);
   crypto::ScopedOpenSSLSafeSizeBuffer<EVP_MAX_MD_SIZE> hmac_result(
       reinterpret_cast<unsigned char*>(result.data()), hmac_expected_length);
 
   crypto::OpenSSLErrStackTracer(FROM_HERE);
 
   unsigned int hmac_actual_length;
-  unsigned char* const success = HMAC(evp_sha,
+  unsigned char* const success = HMAC(digest_algorithm,
                                       raw_key_voidp,
                                       raw_key.size(),
                                       data.bytes(),
                                       data.byte_length(),
                                       hmac_result.safe_buffer(),
                                       &hmac_actual_length);
   if (!success || hmac_actual_length != hmac_expected_length)
     return Status::Error();
 
   *buffer = result;
@@ skipping 76 matching lines @@
 Status ExportKeySpki(PublicKey* key, blink::WebArrayBuffer* buffer) {
   // TODO(eroman): http://crbug.com/267888
   return Status::ErrorUnsupported();
 }
 
 }  // namespace platform
 
 }  // namespace webcrypto
 
 }  // namespace content