[refactor] Misc post-NSS WebCrypto cleanups.

components/webcrypto/algorithms/ecdh_unittest.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 "base/stl_util.h"
 #include "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/algorithms/test_helpers.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/jwk.h"
 #include "components/webcrypto/status.h"
 #include "components/webcrypto/webcrypto_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
 namespace {
 
-bool SupportsEcdh() {
-#if defined(USE_OPENSSL)
-  return true;
-#else
-  LOG(ERROR) << "Skipping ECDH test because unsupported";
-  return false;
-#endif
-}
-
 // TODO(eroman): Test passing an RSA public key instead of ECDH key.
 // TODO(eroman): Test passing an ECDSA public key
 
 blink::WebCryptoAlgorithm CreateEcdhImportAlgorithm(
     blink::WebCryptoNamedCurve named_curve) {
   return CreateEcImportAlgorithm(blink::WebCryptoAlgorithmIdEcdh, named_curve);
 }
 
 blink::WebCryptoAlgorithm CreateEcdhDeriveParams(
     const blink::WebCryptoKey& public_key) {
@@ skipping 38 matching lines @@
       CreateEcdhImportAlgorithm(curve), true,
       blink::WebCryptoKeyUsageDeriveBits | blink::WebCryptoKeyUsageDeriveKey,
       private_key);
   EXPECT_EQ(expected_private_key_error, StatusToString(status));
   return status.IsSuccess();
 }
 
 class WebCryptoEcdhTest : public WebCryptoTestBase {};
 
 TEST_F(WebCryptoEcdhTest, DeriveBitsKnownAnswer) {
-  if (!SupportsEcdh())
-    return;
-
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("ecdh.json", &tests));
 
   for (size_t test_index = 0; test_index < tests->GetSize(); ++test_index) {
     SCOPED_TRACE(test_index);
 
     const base::DictionaryValue* test;
     ASSERT_TRUE(tests->GetDictionary(test_index, &test));
 
     // Import the keys.
@@ skipping 50 matching lines @@
   ImportKeysFromTest(test, public_key, private_key);
 
   EXPECT_EQ(blink::WebCryptoNamedCurveP521,
             public_key->algorithm().ecParams()->namedCurve());
 
   return ::testing::AssertionSuccess();
 }
 
 // Try deriving an AES key of length 129 bits.
 TEST_F(WebCryptoEcdhTest, DeriveKeyBadAesLength) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   ASSERT_EQ(Status::ErrorGetAesKeyLength(),
             DeriveKey(CreateEcdhDeriveParams(public_key), base_key,
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
                       CreateAesGcmDerivedKeyParams(129), true,
                       blink::WebCryptoKeyUsageEncrypt, &derived_key));
 }
 
 // Try deriving an AES key of length 192 bits.
 TEST_F(WebCryptoEcdhTest, DeriveKeyUnsupportedAesLength) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   ASSERT_EQ(Status::ErrorAes192BitUnsupported(),
             DeriveKey(CreateEcdhDeriveParams(public_key), base_key,
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
                       CreateAesGcmDerivedKeyParams(192), true,
                       blink::WebCryptoKeyUsageEncrypt, &derived_key));
 }
 
 // Try deriving an HMAC key of length 0 bits.
 TEST_F(WebCryptoEcdhTest, DeriveKeyZeroLengthHmac) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   const blink::WebCryptoAlgorithm import_algorithm =
       CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1, 0);
 
   ASSERT_EQ(Status::ErrorGetHmacKeyLengthZero(),
             DeriveKey(CreateEcdhDeriveParams(public_key), base_key,
                       import_algorithm, import_algorithm, true,
                       blink::WebCryptoKeyUsageSign, &derived_key));
 }
 
 // Derive an HMAC key of length 19 bits.
 TEST_F(WebCryptoEcdhTest, DeriveKeyHmac19Bits) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   const blink::WebCryptoAlgorithm import_algorithm =
       CreateHmacImportAlgorithm(blink::WebCryptoAlgorithmIdSha1, 19);
 
   ASSERT_EQ(Status::Success(),
@@ skipping 10 matching lines @@
   std::vector<uint8_t> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, derived_key, &raw_key));
   EXPECT_EQ(3u, raw_key.size());
   // The last 7 bits of the key should be zero.
   EXPECT_EQ(0, raw_key[raw_key.size() - 1] & 0x1f);
 }
 
 // Derive an HMAC key with no specified length (just the hash of SHA-256).
 TEST_F(WebCryptoEcdhTest, DeriveKeyHmacSha256NoLength) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   const blink::WebCryptoAlgorithm import_algorithm =
       CreateHmacImportAlgorithmNoLength(blink::WebCryptoAlgorithmIdSha256);
 
   ASSERT_EQ(Status::Success(),
@@ skipping 16 matching lines @@
 // Derive an HMAC key with no specified length (just the hash of SHA-512).
 //
 // This fails, because ECDH using P-521 can only generate 528 bits, however HMAC
 // SHA-512 requires 1024 bits.
 //
 // In practice, authors won't be directly generating keys from key agreement
 // schemes, as that is frequently insecure, and instead be using KDFs to expand
 // and generate keys. For simplicity of testing, however, test using an HMAC
 // key.
 TEST_F(WebCryptoEcdhTest, DeriveKeyHmacSha512NoLength) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   const blink::WebCryptoAlgorithm import_algorithm =
       CreateHmacImportAlgorithmNoLength(blink::WebCryptoAlgorithmIdSha512);
 
   ASSERT_EQ(Status::ErrorEcdhLengthTooBig(528),
             DeriveKey(CreateEcdhDeriveParams(public_key), base_key,
                       import_algorithm, import_algorithm, true,
                       blink::WebCryptoKeyUsageSign, &derived_key));
 }
 
 // Try deriving an AES key of length 128 bits.
 TEST_F(WebCryptoEcdhTest, DeriveKeyAes128) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey public_key;
   blink::WebCryptoKey base_key;
   ASSERT_TRUE(LoadTestKeys(&public_key, &base_key));
 
   blink::WebCryptoKey derived_key;
 
   ASSERT_EQ(Status::Success(),
             DeriveKey(CreateEcdhDeriveParams(public_key), base_key,
                       CreateAlgorithm(blink::WebCryptoAlgorithmIdAesGcm),
                       CreateAesGcmDerivedKeyParams(128), true,
                       blink::WebCryptoKeyUsageEncrypt, &derived_key));
 
   ASSERT_EQ(blink::WebCryptoAlgorithmIdAesGcm, derived_key.algorithm().id());
   ASSERT_EQ(128, derived_key.algorithm().aesParams()->lengthBits());
 
   // Export the key and verify its contents.
   std::vector<uint8_t> raw_key;
   EXPECT_EQ(Status::Success(),
             ExportKey(blink::WebCryptoKeyFormatRaw, derived_key, &raw_key));
   EXPECT_EQ(16u, raw_key.size());
 }
 
 TEST_F(WebCryptoEcdhTest, ImportKeyEmptyUsage) {
-  if (!SupportsEcdh())
-    return;
-
   blink::WebCryptoKey key;
 
   scoped_ptr<base::ListValue> tests;
   ASSERT_TRUE(ReadJsonTestFileToList("ecdh.json", &tests));
 
   const base::DictionaryValue* test;
   ASSERT_TRUE(tests->GetDictionary(0, &test));
 
   // Import the public key.
   const base::DictionaryValue* public_key_json = NULL;
@@ skipping 12 matching lines @@
   curve = GetCurveNameFromDictionary(private_key_json);
   ASSERT_EQ(Status::ErrorCreateKeyEmptyUsages(),
             ImportKey(blink::WebCryptoKeyFormatJwk,
                       CryptoData(MakeJsonVector(*private_key_json)),
                       CreateEcdhImportAlgorithm(curve), true, 0, &key));
 }
 
 }  // namespace
 
 }  // namespace webcrypto