WebCrypto: Implement crypto.subtle.deriveKey (chromium-side).

content/child/webcrypto/algorithm_dispatch.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/algorithm_dispatch.h"
 
 #include "base/logging.h"
 #include "content/child/webcrypto/algorithm_implementation.h"
 #include "content/child/webcrypto/algorithm_registry.h"
 #include "content/child/webcrypto/crypto_data.h"
@@ skipping 238 matching lines @@
     return Status::ErrorUnexpected();
 
   if (algorithm.id() != base_key.algorithm().id())
     return Status::ErrorUnexpected();
 
   const AlgorithmImplementation* impl = NULL;
   Status status = GetAlgorithmImplementation(algorithm.id(), &impl);
   if (status.IsError())
     return status;
 
-  return impl->DeriveBits(algorithm, base_key, length_bits, derived_bytes);
+  return impl->DeriveBits(algorithm, base_key, true, length_bits,
+                          derived_bytes);
+}
+
+Status DeriveKey(const blink::WebCryptoAlgorithm& algorithm,
+                 const blink::WebCryptoKey& base_key,
+                 const blink::WebCryptoAlgorithm& import_algorithm,
+                 const blink::WebCryptoAlgorithm& key_length_algorithm,
+                 bool extractable,
+                 blink::WebCryptoKeyUsageMask usages,
+                 blink::WebCryptoKey* derived_key) {
+  if (!KeyUsageAllows(base_key, blink::WebCryptoKeyUsageDeriveKey))
+    return Status::ErrorUnexpected();
+
+  if (algorithm.id() != base_key.algorithm().id())
+    return Status::ErrorUnexpected();
+
+  if (import_algorithm.id() != key_length_algorithm.id())
+    return Status::ErrorUnexpected();
+
+  const AlgorithmImplementation* import_impl = NULL;
+  Status status =
+      GetAlgorithmImplementation(import_algorithm.id(), &import_impl);
+  if (status.IsError())
+    return status;
+
+  // Fail fast if the requested key usages are incorect.
+  status = import_impl->VerifyKeyUsagesBeforeImportKey(
+      blink::WebCryptoKeyFormatRaw, usages);
+  if (status.IsError())
+    return status;
+
+  // Determine how many bits long the derived key should be.
+  unsigned int length_bits = 0;
+  bool has_length_bits = false;
+  status = import_impl->GetKeyLength(key_length_algorithm, &has_length_bits,
+                                     &length_bits);
+  if (status.IsError())
+    return status;
+
+  // Derive the key bytes.
+  const AlgorithmImplementation* derive_impl = NULL;
+  status = GetAlgorithmImplementation(algorithm.id(), &derive_impl);
+  if (status.IsError())
+    return status;
+
+  std::vector<uint8_t> derived_bytes;
+  status = derive_impl->DeriveBits(algorithm, base_key, has_length_bits,
+                                   length_bits, &derived_bytes);
+  if (status.IsError())
+    return status;
+
+  // Create the key using the derived bytes.
+  return ImportKey(blink::WebCryptoKeyFormatRaw, CryptoData(derived_bytes),
+                   import_algorithm, extractable, usages, derived_key);
 }
 
 scoped_ptr<blink::WebCryptoDigestor> CreateDigestor(
     blink::WebCryptoAlgorithmId algorithm) {
   PlatformInit();
   return CreatePlatformDigestor(algorithm);
 }
 
 bool SerializeKeyForClone(const blink::WebCryptoKey& key,
                           blink::WebVector<uint8_t>* key_data) {
@@ skipping 18 matching lines @@
     return false;
 
   status = impl->DeserializeKeyForClone(algorithm, type, extractable, usages,
                                         key_data, key);
   return status.IsSuccess();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content