[webcrypto] Update to use the KeyAlgorithm.

content/renderer/webcrypto/jwk.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 <algorithm>
 #include <functional>
 #include <map>
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/platform_crypto.h"
 #include "content/renderer/webcrypto/shared_crypto.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
+#include "third_party/WebKit/public/platform/WebCrypto.h"  // TODO(eroman):

[Ryan Sleevi, 2014/02/25 22:26:26]

What's the TODO?

[eroman, 2014/02/25 23:26:47]

Done.

The todo is for me to delete that line. Added a comment to that effect (that
header is where the #define is pulled in from blink).

Apparently clang-format doesn't care about the line being longer than 80 chars

 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 typedef blink::WebCryptoAlgorithm (*AlgorithmCreationFunc)();
 
 class JwkAlgorithmInfo {
  public:
   JwkAlgorithmInfo()
       : creation_func_(NULL),
         required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {}
 
   explicit JwkAlgorithmInfo(AlgorithmCreationFunc algorithm_creation_func)
       : creation_func_(algorithm_creation_func),
         required_key_length_bytes_(NO_KEY_SIZE_REQUIREMENT) {}
 
   JwkAlgorithmInfo(AlgorithmCreationFunc algorithm_creation_func,
                    unsigned int required_key_length_bits)
       : creation_func_(algorithm_creation_func),
         required_key_length_bytes_(required_key_length_bits / 8) {
     DCHECK((required_key_length_bits % 8) == 0);
   }
 
-  bool CreateAlgorithm(blink::WebCryptoAlgorithm* algorithm) const {
+  bool CreateImportAlgorithm(blink::WebCryptoAlgorithm* algorithm) const {
     *algorithm = creation_func_();
     return !algorithm->isNull();
   }
 
   bool IsInvalidKeyByteLength(size_t byte_length) const {
     if (required_key_length_bytes_ == NO_KEY_SIZE_REQUIREMENT)
       return false;
     return required_key_length_bytes_ != byte_length;
   }
 
  private:
   enum { NO_KEY_SIZE_REQUIREMENT = UINT_MAX };
 
   AlgorithmCreationFunc creation_func_;
 
   // The expected key size for the algorithm or NO_KEY_SIZE_REQUIREMENT.
   unsigned int required_key_length_bytes_;
 };
 
 typedef std::map<std::string, JwkAlgorithmInfo> JwkAlgorithmInfoMap;
 
 class JwkAlgorithmRegistry {
  public:
   JwkAlgorithmRegistry() {
     // TODO(eroman):
     // http://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-20
     // says HMAC with SHA-2 should have a key size at least as large as the
     // hash output.
     alg_to_info_["HS256"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha256>);
     alg_to_info_["HS384"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha384>);
     alg_to_info_["HS512"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacAlgorithmByHashId,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateHmacImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha512>);
     alg_to_info_["RS256"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha256>);
     alg_to_info_["RS384"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha384>);
     alg_to_info_["RS512"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaAlgorithm,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaSsaImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha512>);
     alg_to_info_["RSA1_5"] = JwkAlgorithmInfo(
         &BindAlgorithmId<CreateAlgorithm,
                          blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5>);
     alg_to_info_["RSA-OAEP"] =
-        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepAlgorithm,
+        JwkAlgorithmInfo(&BindAlgorithmId<CreateRsaOaepImportAlgorithm,
                                           blink::WebCryptoAlgorithmIdSha1>);
     // TODO(padolph): The Web Crypto spec does not enumerate AES-KW 128 yet
     alg_to_info_["A128KW"] =
         JwkAlgorithmInfo(&blink::WebCryptoAlgorithm::createNull, 128);
     // TODO(padolph): The Web Crypto spec does not enumerate AES-KW 256 yet
     alg_to_info_["A256KW"] =
         JwkAlgorithmInfo(&blink::WebCryptoAlgorithm::createNull, 256);
     alg_to_info_["A128GCM"] = JwkAlgorithmInfo(
         &BindAlgorithmId<CreateAlgorithm, blink::WebCryptoAlgorithmIdAesGcm>,
         128);
@@ skipping 28 matching lines @@
   static blink::WebCryptoAlgorithm BindAlgorithmId() {
     return func(algorithm_id);
   }
 
   JwkAlgorithmInfoMap alg_to_info_;
 };
 
 base::LazyInstance<JwkAlgorithmRegistry> jwk_alg_registry =
     LAZY_INSTANCE_INITIALIZER;
 
-bool WebCryptoAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
-                                   const blink::WebCryptoAlgorithm& alg2) {
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+bool ImportAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
+                                const blink::WebCryptoAlgorithm& alg2) {
   DCHECK(!alg1.isNull());
   DCHECK(!alg2.isNull());
   if (alg1.id() != alg2.id())
+    return false;
+  if (alg1.paramsType() != alg2.paramsType())
+    return false;
+  switch (alg1.paramsType()) {
+    case blink::WebCryptoAlgorithmParamsTypeNone:
+      return true;
+    case blink::WebCryptoAlgorithmParamsTypeRsaHashedImportParams:
+      return ImportAlgorithmsConsistent(alg1.rsaHashedImportParams()->hash(),
+                                        alg2.rsaHashedImportParams()->hash());
+    case blink::WebCryptoAlgorithmParamsTypeHmacImportParams:
+      return ImportAlgorithmsConsistent(alg1.hmacImportParams()->hash(),
+                                        alg2.hmacImportParams()->hash());
+    default:
+      return false;
+  }
+}
+#else
+bool ImportAlgorithmsConsistent(const blink::WebCryptoAlgorithm& alg1,
+                                const blink::WebCryptoAlgorithm& alg2) {
+  DCHECK(!alg1.isNull());
+  DCHECK(!alg2.isNull());
+  if (alg1.id() != alg2.id())
     return false;
   switch (alg1.id()) {
     case blink::WebCryptoAlgorithmIdHmac:
     case blink::WebCryptoAlgorithmIdRsaOaep:
     case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-      if (WebCryptoAlgorithmsConsistent(GetInnerHashAlgorithm(alg1),
-                                        GetInnerHashAlgorithm(alg2))) {
+      if (ImportAlgorithmsConsistent(GetInnerHashAlgorithm(alg1),
+                                     GetInnerHashAlgorithm(alg2))) {
         return true;
       }
       break;
     case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
     case blink::WebCryptoAlgorithmIdSha1:
     case blink::WebCryptoAlgorithmIdSha224:
     case blink::WebCryptoAlgorithmIdSha256:
     case blink::WebCryptoAlgorithmIdSha384:
     case blink::WebCryptoAlgorithmIdSha512:
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesCtr:
       return true;
     default:
       NOTREACHED();  // Not a supported algorithm.
       break;
   }
   return false;
 }
+#endif
 
 // Extracts the required string property with key |path| from |dict| and saves
 // the result to |*result|. If the property does not exist or is not a string,
 // returns an error.
 Status GetJwkString(base::DictionaryValue* dict,
                     const std::string& path,
                     std::string* result) {
   base::Value* value = NULL;
   if (!dict->Get(path, &value))
     return Status::ErrorJwkPropertyMissing(path);
@@ skipping 256 matching lines @@
 
   if (has_jwk_alg) {
     // JWK alg present
 
     // TODO(padolph): Validate alg vs kty. For example kty="RSA" implies alg can
     // only be from the RSA family.
 
     blink::WebCryptoAlgorithm jwk_algorithm =
         blink::WebCryptoAlgorithm::createNull();
     algorithm_info = jwk_alg_registry.Get().GetAlgorithmInfo(jwk_alg_value);
-    if (!algorithm_info || !algorithm_info->CreateAlgorithm(&jwk_algorithm))
+    if (!algorithm_info ||
+        !algorithm_info->CreateImportAlgorithm(&jwk_algorithm))
       return Status::ErrorJwkUnrecognizedAlgorithm();  // case 1
 
     // JWK alg valid
     if (algorithm_or_null.isNull()) {
       // input algorithm not specified
       algorithm = jwk_algorithm;  // case 2
     } else {
       // input algorithm specified
-      if (!WebCryptoAlgorithmsConsistent(jwk_algorithm, algorithm_or_null))
+      if (!ImportAlgorithmsConsistent(jwk_algorithm, algorithm_or_null))
         return Status::ErrorJwkAlgorithmInconsistent();  // case 3
       algorithm = algorithm_or_null;                     // case 4
     }
   } else {
     // JWK alg missing
     if (algorithm_or_null.isNull())
       return Status::ErrorJwkAlgorithmMissing();  // case 5
     algorithm = algorithm_or_null;                // case 6
   }
   DCHECK(!algorithm.isNull());
@@ skipping 83 matching lines @@
   } else {
     return Status::ErrorJwkUnrecognizedKty();
   }
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content