Extension API enterprise.platformKeys.

chrome/renderer/resources/extensions/enterprise_platform_keys/enterprise_platform_keys_subtle_crypto.js

Index: chrome/renderer/resources/extensions/enterprise_platform_keys/enterprise_platform_keys_subtle_crypto.js
diff --git a/chrome/renderer/resources/extensions/enterprise_platform_keys/enterprise_platform_keys_subtle_crypto.js b/chrome/renderer/resources/extensions/enterprise_platform_keys/enterprise_platform_keys_subtle_crypto.js
new file mode 100644
index 0000000000000000000000000000000000000000..be7dd9bd62121bf2acd94834c3e8dc19253557c9
--- /dev/null
+++ b/chrome/renderer/resources/extensions/enterprise_platform_keys/enterprise_platform_keys_subtle_crypto.js
@@ -0,0 +1,88 @@
+// 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.
+
+var utils = require('utils');
+var internalAPI = require('enterprise.platformKeysInternal').binding;
+var intersect = require('enterprise.platformKeys.utils').intersect;
+var keyModule = require('enterprise.platformKeys.Key');
+var Key = keyModule.Key;
+var KeyImpl = keyModule.KeyImpl;
+var KeyPair = keyModule.KeyPair;
+var KeyUsage = keyModule.KeyUsage;
+
+/**
+ * Implementation of WebCrypto.SubtleCrypto used in enterprise.platformKeys.
+ * @param {string} tokenId The id of the backing Token.
+ * @constructor
+ */
+var SubtleCryptoImpl = function(tokenId) {
+  this.tokenId = tokenId;
+};
+
+SubtleCryptoImpl.prototype.generateKey =
+    function(algorithm, extractable, keyUsages) {
+  var subtleCrypto = this;
+  return new Promise(function(resolve, reject) {
+    if (extractable)
+      throw new Error('Extractable keys are not supported.');
+    if (intersect(keyUsages, [KeyUsage.sign, KeyUsage.verify]).length !=
+        keyUsages.length) {
+      throw new Error(
+          'Unsupported keyUsages. Only "sign" and "verify" supported.');
+    }

[not at google - send to devlin, 2014/05/05 21:09:24]

all of this validation could happen before returning the Promise. it's probably
better to have these invalid-input checks up-front rather than on resolution of
the promise?

[pneubeck (no reviews), 2014/05/05 21:28:23]

As far as I understand the Promise thing, reject should be called on any
error/exception.

+    if (algorithm.name != 'RSASSA-PKCS1-v1_5')
+      throw new Error('The algorithm is not supported');

[not at google - send to devlin, 2014/05/05 21:09:24]

maybe include the name of the algorithm in this failure?

[pneubeck (no reviews), 2014/05/06 14:07:21]

The errors are specified by SubtleCrypto (using DOMException).
However, I don't know yet how to create DOMExceptions from JS.
I think that will need a native module, so I'd postpone that for now.

http://www.w3.org/TR/WebCryptoAPI/#SubtleCrypto-Exceptions

+
+    internalAPI.generateKey(subtleCrypto.tokenId, function(spki) {
+      if (chrome.runtime.lastError) {
+        reject(chrome.runtime.lastError);
+        return;
+      }
+      resolve(new KeyPair(spki, algorithm, keyUsages));
+    });
+  });
+};
+
+SubtleCryptoImpl.prototype.sign = function(algorithm, key, dataView) {
+  var subtleCrypto = this;
+  return new Promise(function(resolve, reject) {
+    var keyImpl = privates(key).impl;

[not at google - send to devlin, 2014/05/05 21:09:24]

same comments as above

[pneubeck (no reviews), 2014/05/06 14:07:21]

Done.

+    if (!(keyImpl instanceof KeyImpl))

[not at google - send to devlin, 2014/05/05 21:09:24]

instanceof is dangerous in bindings files because extensions/apps can have
multiple contexts, meaning different copies of each API binding, and instanceof
doesn't work across bindings. it means you might have problems using keys from
the background page in an app window or popup etc.

besides which, exposing the Impl to this class is unusual. better for
encapsulation to have this logic be defined where the class is. e.g. can the
sign() functionality live in the key.js file somehow?

[pneubeck (no reviews), 2014/05/05 21:28:23]

The only reason why I added this was, that I wanted to ensure that no one is
spoofing this implementation with a fake Key object.
I guess, I don't need the instanceOf check, if I already access
privates(key).impl, which shouldn't be fakeable.

On 2014/05/05 21:09:24, kalman wrote:

[pneubeck (no reviews), 2014/05/06 14:07:21]

I removed the dependence on the class KeyImpl from this file.

I don't think that the crypto operations belong to the Key implementation. The
Key's public key information is just one of the arguments, the Token for example
being another.
The way it's currently, Key is only carrying some (private) data.
I made this now more explicit by exposing an internal getSpki function.

+      throw new Error('Invalid key object.');
+    if (key.type != 'private')
+      throw new Error('Key type not supported.');
+
+    // Create an ArrayBuffer that equals the dataView. Note that dataView.buffer
+    // might contain more data than dataView.
+    var data = dataView.buffer.slice(dataView.byteOffset,
+                                     dataView.byteOffset + dataView.byteLength);
+    internalAPI.sign(
+        subtleCrypto.tokenId, keyImpl.spki, data, function(signature) {
+          if (chrome.runtime.lastError) {
+            reject(chrome.runtime.lastError);
+            return;
+          }
+          resolve(signature);
+        });
+  });
+};
+
+SubtleCryptoImpl.prototype.exportKey = function(format, key) {

[not at google - send to devlin, 2014/05/05 21:09:24]

same comments here

[pneubeck (no reviews), 2014/05/06 14:07:21]

Done.

+  return new Promise(function(resolve, reject) {
+    if (format != 'spki')
+      throw new Error('Format not supported.');
+    var keyImpl = privates(key).impl;
+    if (!(keyImpl instanceof KeyImpl))
+      throw new Error('Invalid key object.');
+    if (key.type != 'public')
+      throw new Error('Key type not supported.');
+
+    resolve(keyImpl.spki);
+  });
+};
+
+exports.SubtleCrypto =
+    utils.expose('SubtleCrypto',
+                 SubtleCryptoImpl,
+                 {functions:['generateKey', 'sign', 'exportKey']});