[webcrypto] Enable wrap/unwrap for SPKI and PKCS8.

content/child/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/child/webcrypto/shared_crypto.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/jwk.h"
 #include "content/child/webcrypto/platform_crypto.h"
@@ skipping 847 matching lines @@
 Status WrapKey(blink::WebCryptoKeyFormat format,
                const blink::WebCryptoKey& key_to_wrap,
                const blink::WebCryptoKey& wrapping_key,
                const blink::WebCryptoAlgorithm& wrapping_algorithm,
                std::vector<uint8>* buffer) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageWrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
-  switch (format) {
-    case blink::WebCryptoKeyFormatRaw:
-      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
-        // AES-KW is a special case, due to NSS's implementation only
-        // supporting C_Wrap/C_Unwrap with AES-KW
-        return WrapKeyRaw(
-            key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
-      }
-      return WrapKeyExportAndEncrypt(
-          format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
-    case blink::WebCryptoKeyFormatJwk:
-      return WrapKeyExportAndEncrypt(
-          format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
-    case blink::WebCryptoKeyFormatSpki:
-    case blink::WebCryptoKeyFormatPkcs8:
-      return Status::ErrorUnsupported();  // TODO(padolph)
-    default:
-      NOTREACHED();
-      return Status::ErrorUnsupported();
+  if (format == blink::WebCryptoKeyFormatRaw &&
+      wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
+    // AES-KW is a special case, due to NSS's implementation only
+    // supporting C_Wrap/C_Unwrap with AES-KW
+    return WrapKeyRaw(key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
   }
+
+  return WrapKeyExportAndEncrypt(
+      format, key_to_wrap, wrapping_key, wrapping_algorithm, buffer);
 }
 
 Status UnwrapKey(blink::WebCryptoKeyFormat format,
                  const CryptoData& wrapped_key_data,
                  const blink::WebCryptoKey& wrapping_key,
                  const blink::WebCryptoAlgorithm& wrapping_algorithm,
                  const blink::WebCryptoAlgorithm& algorithm,
                  bool extractable,
                  blink::WebCryptoKeyUsageMask usage_mask,
                  blink::WebCryptoKey* key) {
   if (!KeyUsageAllows(wrapping_key, blink::WebCryptoKeyUsageUnwrapKey))
     return Status::ErrorUnexpected();
   if (wrapping_algorithm.id() != wrapping_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   // Fail-fast if the key usages don't make sense. This avoids decrypting the
   // key only to then have import fail. It is "best effort" because when
   // unwrapping JWK for asymmetric algorithms the key type isn't known yet.
   Status status =
       BestEffortCheckKeyUsagesForImport(algorithm.id(), format, usage_mask);
   if (status.IsError())
     return status;
 
-  switch (format) {
-    case blink::WebCryptoKeyFormatRaw:
-      if (wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
-        // AES-KW is a special case, due to NSS's implementation only
-        // supporting C_Wrap/C_Unwrap with AES-KW
-        return UnwrapKeyRaw(wrapped_key_data,
-                            wrapping_key,
-                            wrapping_algorithm,
-                            algorithm,
-                            extractable,
-                            usage_mask,
-                            key);
-      }
-      return UnwrapKeyDecryptAndImport(format,
-                                       wrapped_key_data,
-                                       wrapping_key,
-                                       wrapping_algorithm,
-                                       algorithm,
-                                       extractable,
-                                       usage_mask,
-                                       key);
-    case blink::WebCryptoKeyFormatJwk:
-      return UnwrapKeyDecryptAndImport(format,
-                                       wrapped_key_data,
-                                       wrapping_key,
-                                       wrapping_algorithm,
-                                       algorithm,
-                                       extractable,
-                                       usage_mask,
-                                       key);
-    case blink::WebCryptoKeyFormatSpki:
-    case blink::WebCryptoKeyFormatPkcs8:
-      return Status::ErrorUnsupported();  // TODO(padolph)
-    default:
-      NOTREACHED();
-      return Status::ErrorUnsupported();
+  if (format == blink::WebCryptoKeyFormatRaw &&
+      wrapping_algorithm.id() == blink::WebCryptoAlgorithmIdAesKw) {
+    // AES-KW is a special case, due to NSS's implementation only
+    // supporting C_Wrap/C_Unwrap with AES-KW
+    return UnwrapKeyRaw(wrapped_key_data,
+                        wrapping_key,
+                        wrapping_algorithm,
+                        algorithm,
+                        extractable,
+                        usage_mask,
+                        key);
   }
+
+  return UnwrapKeyDecryptAndImport(format,
+                                   wrapped_key_data,
+                                   wrapping_key,
+                                   wrapping_algorithm,
+                                   algorithm,
+                                   extractable,
+                                   usage_mask,
+                                   key);
 }
 
 // Note that this function is called from the target Blink thread.
 bool SerializeKeyForClone(const blink::WebCryptoKey& key,
                           blink::WebVector<uint8>* key_data) {
   return static_cast<webcrypto::platform::Key*>(key.handle())
       ->ThreadSafeSerializeForClone(key_data);
 }
 
 // Note that this function is called from the target Blink thread.
@@ skipping 54 matching lines @@
   if (!ContainsKeyUsages(GetValidKeyUsagesForKeyType(algorithm, key_type),
                          usages))
     return Status::ErrorCreateKeyBadUsages();
 
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content