[webcrypto] Update to use the KeyAlgorithm.

content/renderer/webcrypto/shared_crypto.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/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/renderer/webcrypto/crypto_data.h"
 #include "content/renderer/webcrypto/platform_crypto.h"
 #include "content/renderer/webcrypto/webcrypto_util.h"
 #include "crypto/secure_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+#include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
+#endif
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"
 
 namespace content {
 
 namespace webcrypto {
 
 namespace {
 
 // TODO(eroman): Move this helper to WebCryptoKey.
 bool KeyUsageAllows(const blink::WebCryptoKey& key,
@@ skipping 123 matching lines @@
 
 Status SignHmac(const blink::WebCryptoAlgorithm& algorithm,
                 const blink::WebCryptoKey& key,
                 const CryptoData& data,
                 blink::WebArrayBuffer* buffer) {
   platform::SymKey* sym_key;
   Status status = ToPlatformSymKey(key, &sym_key);
   if (status.IsError())
     return status;
 
-  const blink::WebCryptoHmacParams* params = algorithm.hmacParams();
-  if (!params)
-    return Status::ErrorUnexpected();
-
-  if (!IsHashAlgorithm(params->hash().id()))
-    return Status::ErrorUnexpected();
-
-  if (params->hash().id() != GetInnerHashAlgorithm(key.algorithm()).id())
-    return Status::ErrorUnexpected();
-
-  return platform::SignHmac(sym_key, params->hash(), data, buffer);
+  return platform::SignHmac(
+      sym_key, key.algorithm().hmacParams()->hash(), data, buffer);
 }
 
 Status VerifyHmac(const blink::WebCryptoAlgorithm& algorithm,
                   const blink::WebCryptoKey& key,
                   const CryptoData& signature,
                   const CryptoData& data,
                   bool* signature_match) {
   blink::WebArrayBuffer result;
   Status status = SignHmac(algorithm, key, data, &result);
   if (status.IsError())
@@ skipping 10 matching lines @@
 
 Status SignRsaSsaPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
                            const blink::WebCryptoKey& key,
                            const CryptoData& data,
                            blink::WebArrayBuffer* buffer) {
   platform::PrivateKey* private_key;
   Status status = ToPlatformPrivateKey(key, &private_key);
   if (status.IsError())
     return status;
 
-  const blink::WebCryptoRsaSsaParams* params = algorithm.rsaSsaParams();
-  if (!params)
-    return Status::ErrorUnexpected();
-
-  if (!IsHashAlgorithm(params->hash().id()))
-    return Status::ErrorUnexpected();
-
-  // TODO(eroman): Verify the key has not been used with any other hash.
-
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   return platform::SignRsaSsaPkcs1v1_5(
-      private_key, params->hash(), data, buffer);
+      private_key, key.algorithm().rsaHashedParams()->hash(), data, buffer);
+#else
+  return platform::SignRsaSsaPkcs1v1_5(
+      private_key, algorithm.rsaSsaParams()->hash(), data, buffer);
+#endif
 }
 
 Status VerifyRsaSsaPkcs1v1_5(const blink::WebCryptoAlgorithm& algorithm,
                              const blink::WebCryptoKey& key,
                              const CryptoData& signature,
                              const CryptoData& data,
                              bool* signature_match) {
   platform::PublicKey* public_key;
   Status status = ToPlatformPublicKey(key, &public_key);
   if (status.IsError())
     return status;
 
-  const blink::WebCryptoRsaSsaParams* params = algorithm.rsaSsaParams();
-  if (!params)
-    return Status::ErrorUnexpected();
-
-  if (!IsHashAlgorithm(params->hash().id()))
-    return Status::ErrorUnexpected();
-
-  // TODO(eroman): Verify the key has not been used with any other hash.
-
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
   return platform::VerifyRsaSsaPkcs1v1_5(
-      public_key, params->hash(), signature, data, signature_match);
+      public_key,
+      key.algorithm().rsaHashedParams()->hash(),
+      signature,
+      data,
+      signature_match);
+#else
+  return platform::VerifyRsaSsaPkcs1v1_5(public_key,
+                                         algorithm.rsaSsaParams()->hash(),
+                                         signature,
+                                         data,
+                                         signature_match);
+#endif
 }
 
 Status ImportKeyRaw(const CryptoData& key_data,
                     const blink::WebCryptoAlgorithm& algorithm_or_null,
                     bool extractable,
                     blink::WebCryptoKeyUsageMask usage_mask,
                     blink::WebCryptoKey* key) {
   if (algorithm_or_null.isNull())
     return Status::ErrorMissingAlgorithmImportRawKey();
 
   switch (algorithm_or_null.id()) {
+    case blink::WebCryptoAlgorithmIdAesCtr:
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw:
       if (!IsValidAesKeyLengthBytes(key_data.byte_length()))
         return Status::Error();
     // Fallthrough intentional!
     case blink::WebCryptoAlgorithmIdHmac:
       return platform::ImportKeyRaw(
           algorithm_or_null, key_data, extractable, usage_mask, key);
-
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 }  // namespace
 
 void Init() { platform::Init(); }
 
 Status Encrypt(const blink::WebCryptoAlgorithm& algorithm,
@@ skipping 64 matching lines @@
   switch (algorithm.id()) {
     case blink::WebCryptoAlgorithmIdAesCbc:
     case blink::WebCryptoAlgorithmIdAesGcm:
     case blink::WebCryptoAlgorithmIdAesKw: {
       if (!IsValidAesKeyLengthBits(algorithm.aesKeyGenParams()->lengthBits()))
         return Status::ErrorGenerateKeyLength();
       keylen_bytes = algorithm.aesKeyGenParams()->lengthBits() / 8;
       break;
     }
     case blink::WebCryptoAlgorithmIdHmac: {
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+      const blink::WebCryptoHmacKeyGenParams* params =
+          algorithm.hmacKeyGenParams();
+#else
       const blink::WebCryptoHmacKeyParams* params = algorithm.hmacKeyParams();
+#endif
       DCHECK(params);
       if (params->hasLengthBytes()) {
         keylen_bytes = params->optionalLengthBytes();
       } else {
         keylen_bytes = ShaBlockSizeBytes(params->hash().id());
         if (keylen_bytes == 0)
           return Status::ErrorUnsupported();
       }
       break;
     }
@@ skipping 10 matching lines @@
   return platform::GenerateSecretKey(
       algorithm, extractable, usage_mask, keylen_bytes, key);
 }
 
 Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usage_mask,
                        blink::WebCryptoKey* public_key,
                        blink::WebCryptoKey* private_key) {
   // TODO(padolph): Handle other asymmetric algorithm key generation.
-  switch (algorithm.id()) {
-    case blink::WebCryptoAlgorithmIdRsaEsPkcs1v1_5:
-    case blink::WebCryptoAlgorithmIdRsaOaep:
-    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
-      if (!algorithm.rsaKeyGenParams())
-        return Status::ErrorUnexpected();
-      return platform::GenerateRsaKeyPair(
-          algorithm, extractable, usage_mask, public_key, private_key);
+  switch (algorithm.paramsType()) {
+#ifdef WEBCRYPTO_HAS_KEY_ALGORITHM
+    case blink::WebCryptoAlgorithmParamsTypeRsaHashedKeyGenParams:
+    case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams: {
+      const blink::WebCryptoRsaKeyGenParams* params = NULL;
+      blink::WebCryptoAlgorithm hash_or_null =
+          blink::WebCryptoAlgorithm::createNull();
+      if (algorithm.rsaHashedKeyGenParams()) {
+        params = algorithm.rsaHashedKeyGenParams();
+        hash_or_null = algorithm.rsaHashedKeyGenParams()->hash();
+      } else {
+        params = algorithm.rsaKeyGenParams();
+      }
+#else
+    case blink::WebCryptoAlgorithmParamsTypeRsaKeyGenParams: {
+      const blink::WebCryptoRsaKeyGenParams* params =
+          algorithm.rsaKeyGenParams();
+      blink::WebCryptoAlgorithm hash_or_null =
+          blink::WebCryptoAlgorithm::createNull();
+#endif
+
+      if (!params->modulusLengthBits())
+        return Status::ErrorGenerateRsaZeroModulus();
+
+      CryptoData publicExponent(params->publicExponent());
+      if (!publicExponent.byte_length())
+        return Status::ErrorGenerateKeyPublicExponent();
+
+      return platform::GenerateRsaKeyPair(algorithm,
+                                          extractable,
+                                          usage_mask,
+                                          params->modulusLengthBits(),
+                                          publicExponent,
+                                          hash_or_null,
+                                          public_key,
+                                          private_key);
+    }
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 Status ImportKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& key_data,
                  const blink::WebCryptoAlgorithm& algorithm_or_null,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usage_mask,
                  blink::WebCryptoKey* key) {
   switch (format) {
     case blink::WebCryptoKeyFormatRaw:
       return ImportKeyRaw(
           key_data, algorithm_or_null, extractable, usage_mask, key);
       return platform::ImportKeyRaw(
           algorithm_or_null, key_data, extractable, usage_mask, key);
     case blink::WebCryptoKeyFormatSpki:
       return platform::ImportKeySpki(
-          algorithm_or_null, key_data, extractable, usage_mask, key);
+          algorithm_or_null, key_data, usage_mask, key);
     case blink::WebCryptoKeyFormatPkcs8:
       return platform::ImportKeyPkcs8(
           algorithm_or_null, key_data, extractable, usage_mask, key);
     case blink::WebCryptoKeyFormatJwk:
       return ImportKeyJwk(
           key_data, algorithm_or_null, extractable, usage_mask, key);
     default:
       return Status::ErrorUnsupported();
   }
 }
@@ skipping 72 matching lines @@
       return VerifyRsaSsaPkcs1v1_5(
           algorithm, key, signature, data, signature_match);
     default:
       return Status::ErrorUnsupported();
   }
 }
 
 }  // namespace webcrypto
 
 }  // namespace content