enterprise.platformKeys: Support the publicExponent parameter.

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

 // 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.platformKeys.internalAPI');
 var intersect = require('enterprise.platformKeys.utils').intersect;
 var KeyPair = require('enterprise.platformKeys.KeyPair').KeyPair;
 var keyModule = require('enterprise.platformKeys.Key');
 var getSpki = keyModule.getSpki;
@@ skipping 33 matching lines @@
 // returns true.
 function catchInvalidTokenError(reject) {
   if (chrome.runtime.lastError &&
       chrome.runtime.lastError.message == errorInvalidToken) {
     reject(chrome.runtime.lastError);
     return true;
   }
   return false;
 }
 
+// Returns true if |array| is a BigInteger describing the standard public
+// exponent 65537.

[eroman, 2014/06/09 22:49:01]

The description could be clearer, indicating that it is allowing leading zeros.

[pneubeck (no reviews), 2014/06/16 17:54:51]

Done.

+function equalsStandardPublicExponent(array) {
+  var expected = [0x01, 0x00, 0x01];
+  if (array.length < expected.length)
+    return false;
+  for (var i = 0; i < array.length; i++) {
+    var expectedDigit = 0;
+    if (i < expected.length) {
+      // |expected| is symmetric, endianness doesn't matter.
+      expectedDigit = expected[i];
+    }
+    if (array[array.length - 1 - i] !== expectedDigit)
+      return false;
+  }
+  return true;
+}
+
 /**
  * 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 =
@@ skipping 12 matching lines @@
       throw CreateDataError();
     }
     var normalizedAlgorithmParameters =
         normalizeAlgorithm(algorithm, 'GenerateKey');
     if (!normalizedAlgorithmParameters) {
       // TODO(pneubeck): It's not clear from the WebCrypto spec which error to
       // throw here.
       throw CreateSyntaxError();
     }
 
-    if (normalizedAlgorithmParameters.name !== 'RSASSA-PKCS1-v1_5') {
+    if (normalizedAlgorithmParameters.name !== 'RSASSA-PKCS1-v1_5' ||
+        !equalsStandardPublicExponent(
+            normalizedAlgorithmParameters.publicExponent)) {
       // Note: This deviates from WebCrypto.SubtleCrypto.
       throw CreateNotSupportedError();
     }
 
     internalAPI.generateKey(subtleCrypto.tokenId,
                             normalizedAlgorithmParameters.modulusLength,
                             function(spki) {
       if (catchInvalidTokenError(reject))
         return;
       if (chrome.runtime.lastError) {
@@ skipping 50 matching lines @@
       // TODO(pneubeck): It should be possible to export to format 'jwk'.
       throw CreateNotSupportedError();
     }
   });
 };
 
 exports.SubtleCrypto =
     utils.expose('SubtleCrypto',
                  SubtleCryptoImpl,
                  {functions:['generateKey', 'sign', 'exportKey']});