Reuse WebCrypto's normalizeCryptoAlgorithm in enterprise.platformKeys.

chrome/renderer/extensions/enterprise_platform_keys_natives.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 "chrome/renderer/extensions/enterprise_platform_keys_natives.h"
+
+#include <string>
+
+#include "base/values.h"
+#include "chrome/renderer/extensions/chrome_v8_context.h"
+#include "content/public/renderer/v8_value_converter.h"
+#include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
+#include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/web/WebCryptoNormalize.h"
+
+namespace extensions {
+
+namespace {
+
+std::string AlgorithmIdToName(blink::WebCryptoAlgorithmId id) {

[eroman, 2014/06/05 23:38:28]

This is a duplication of algorithmIdToName(blink::WebCryptoAlgorithmId) in
NormalizeAlgorithm.h.

You can expose that instead (perhaps as a WebCryptoAlgorithm::idToName()
method?).

[pneubeck (no reviews), 2014/06/06 12:39:45]

Done.

+  switch (id) {
+    case blink::WebCryptoAlgorithmIdHmac:
+      return "HMAC";
+    case blink::WebCryptoAlgorithmIdSha1:
+      return "SHA-1";
+    case blink::WebCryptoAlgorithmIdAesKw:
+      return "AES-KW";
+    case blink::WebCryptoAlgorithmIdSha512:
+      return "SHA-512";
+    case blink::WebCryptoAlgorithmIdSha384:
+      return "SHA-384";
+    case blink::WebCryptoAlgorithmIdSha256:
+      return "SHA-256";
+    case blink::WebCryptoAlgorithmIdAesCbc:
+      return "AES-CBC";
+    case blink::WebCryptoAlgorithmIdAesGcm:
+      return "AES-GCM";
+    case blink::WebCryptoAlgorithmIdAesCtr:
+      return "AES-CTR";
+    case blink::WebCryptoAlgorithmIdRsaOaep:
+      return "RSA-OAEP";
+    case blink::WebCryptoAlgorithmIdRsaSsaPkcs1v1_5:
+      return "RSASSA-PKCS1-V1_5";

[eroman, 2014/06/05 23:38:28]

Note that the canonicalized name used by the spec and elsewhere in webcrypto has
a lowercase v:
  RSASSA-PKCS1-v1_5

[pneubeck (no reviews), 2014/06/06 12:39:45]

Done.

+  }
+  NOTREACHED();
+  return "";
+}
+
+bool StringToWebCryptoOperation(const std::string& str,
+                                blink::WebCryptoOperation* op) {
+  if (str == "GenerateKey") {
+    *op = blink::WebCryptoOperationGenerateKey;
+    return true;
+  }
+  if (str == "Sign") {
+    *op = blink::WebCryptoOperationSign;
+    return true;
+  }
+  if (str == "Verify") {
+    *op = blink::WebCryptoOperationVerify;
+    return true;
+  }
+  return false;
+}
+
+scoped_ptr<base::DictionaryValue> WebCryptoAlgorithmToBaseValue(
+    const blink::WebCryptoAlgorithm& algorithm) {
+  DCHECK(!algorithm.isNull());
+
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+  dict->SetStringWithoutPathExpansion("name",
+                                      AlgorithmIdToName(algorithm.id()));
+  const blink::WebCryptoRsaHashedKeyGenParams* rsaHashedKeyGen =
+      algorithm.rsaHashedKeyGenParams();
+  if (rsaHashedKeyGen) {
+    dict->SetIntegerWithoutPathExpansion("modulusLength",
+                                         rsaHashedKeyGen->modulusLengthBits());

[eroman, 2014/06/05 23:38:27]

What about the hash property?

I am not sure I understand the usage of normalizeCryptoAlgorithm here. Why is it
necessary to convert back to a javascript object. Can you instead call
normalizeCryptoAlgorithm at at point where it is last needed?

Is the issue that you need to do the conversion in the renderer, and are
converting it to a value to be sent to the browser here?

[pneubeck (no reviews), 2014/06/06 12:39:45]

Like pulic exponent, I'd put that into a follow up.
Exactly. We maybe could get rid of this conversion, if normalizeCryptoAlgorithm
wouldn't depend on V8 (e.g. base::Value instead of v8's Dictionary)

+    return dict.Pass();
+  }
+  // Otherwise, |algorithm| is missing support here or no parameters were
+  // required.
+  return dict.Pass();
+}
+
+}  // namespace
+
+EnterprisePlatformKeysNatives::EnterprisePlatformKeysNatives(
+    ScriptContext* context)
+    : ObjectBackedNativeHandler(context) {
+  RouteFunction("NormalizeAlgorithm",
+                base::Bind(&EnterprisePlatformKeysNatives::NormalizeAlgorithm,
+                           base::Unretained(this)));
+}
+
+void EnterprisePlatformKeysNatives::NormalizeAlgorithm(
+    const v8::FunctionCallbackInfo<v8::Value>& call_info) {
+  DCHECK_EQ(call_info.Length(), 2);
+  DCHECK(call_info[0]->IsObject());
+  DCHECK(call_info[1]->IsString());
+
+  blink::WebCryptoOperation operation;
+  if (!StringToWebCryptoOperation(*v8::String::Utf8Value(call_info[1]),
+                                  &operation)) {
+    return;
+  }
+
+  blink::WebString error_details;

[eroman, 2014/06/05 23:38:27]

The exception information is being disregarded, is that intentional?

[pneubeck (no reviews), 2014/06/06 12:39:45]

I wanted to do another pass to fix error handling in a follow up. E.g. it's
unclear whether I should also use DOMExceptions as these are reserved for Web
APIs, AFAIK.

+  int exception_code = 0;
+
+  blink::WebCryptoAlgorithm algorithm =
+      blink::normalizeCryptoAlgorithm(call_info[0]->ToObject(),
+                                      operation,
+                                      &exception_code,
+                                      &error_details,
+                                      call_info.GetIsolate());
+
+  scoped_ptr<base::DictionaryValue> algorithm_dict;
+  if (!algorithm.isNull())
+    algorithm_dict = WebCryptoAlgorithmToBaseValue(algorithm);
+
+  if (!algorithm_dict)
+    return;
+
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
+  call_info.GetReturnValue().Set(
+      converter->ToV8Value(algorithm_dict.get(), context()->v8_context()));
+}
+
+}  // namespace extensions