enterprise.platformKeys: Support the publicExponent parameter.

chrome/test/data/extensions/api_test/enterprise_platform_keys/basic.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.
 
 // Must be packed to ../enterprise_platform_keys.crx using the private key
 // ../enterprise_platform_keys.pem .
 
 var assertEq = chrome.test.assertEq;
 var assertTrue = chrome.test.assertTrue;
 var assertThrows = chrome.test.assertThrows;
@@ skipping 260 matching lines @@
     },
     function initiallyNoCerts() { assertCertsStored(userToken, []); },
 
     // Generates a key and sign some data with it. Verifies the signature using
     // WebCrypto.
     function generateKeyAndSign() {
       var algorithm = {
         name: "RSASSA-PKCS1-v1_5",
         // RsaHashedKeyGenParams
         modulusLength: 512,
-        publicExponent:
-            new Uint8Array([0x01, 0x00, 0x01]),  // Equivalent to 65537
+        // Use some non-standard exponent. This one is equivalent to 257
+        publicExponent: new Uint8Array([0x01, 0x01]),
         hash: {
           name: "SHA-1",
         }
       };
       // Some random data to sign.
       var data = new Uint8Array([0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6]);
       var cachedKeyPair;
       var cachedSpki;
       var cachedSignature;
       userToken.subtleCrypto.generateKey(algorithm, false, ["sign"])
           .then(callbackPass(function(keyPair) {
                   assertTrue(!!keyPair, "No key pair.");
                   cachedKeyPair = keyPair;
                   return userToken.subtleCrypto.exportKey('spki',
                                                           keyPair.publicKey);
                 }),
                 function(error) {
             assertTrue(false, "GenerateKey failed: " + error);
           })
           .then(callbackPass(function(publicKeySpki) {
                   cachedSpki = publicKeySpki;
                   var signParams = {name: 'RSASSA-PKCS1-v1_5'};
                   return userToken.subtleCrypto.sign(
                       signParams, cachedKeyPair.privateKey, data);
                 }),
                 function(error) {
             assertTrue(false, "Export failed: " + error);
           })
           .then(callbackPass(function(signature) {
+                  var importParams = {
+                    name: algorithm.name,
+                    // RsaHashedImportParams
+                    hash: {
+                      name: "SHA-1",
+                    }
+                  };
                   assertTrue(!!signature, "No signature.");
                   assertTrue(signature.length != 0, "Signature is empty.");
                   cachedSignature = signature;
                   return window.crypto.subtle.importKey(
-                      "spki", cachedSpki, algorithm, false, ["verify"]);
+                      "spki", cachedSpki, importParams, false, ["verify"]);
                 }),
                 function(error) { assertTrue(false, "Sign failed: " + error); })
           .then(callbackPass(function(webCryptoPublicKey) {
                   assertTrue(!!webCryptoPublicKey);
                   assertEq(algorithm.modulusLength,
                            webCryptoPublicKey.algorithm.modulusLength);
+                  console.log(algorithm.publicExponent);
+                  assertEq(algorithm.publicExponent,
+                           webCryptoPublicKey.algorithm.publicExponent);
                   return window.crypto.subtle.verify(
                       algorithm, webCryptoPublicKey, cachedSignature, data);
                 }),
                 function(error) {
             assertTrue(false, "Import failed: " + error);
           })
           .then(callbackPass(function(success) {
                   assertEq(true, success, "Signature invalid.");
                 }),
                 function(error) {
@@ skipping 94 matching lines @@
           callbackFail('Certificate is not a valid X.509 certificate.'));
     },
     function getCertsInvalidToken() {
       chrome.enterprise.platformKeys.getCertificates(
           'invalid token id', callbackFail('The token is not valid.'));
     }
   ]);
 }
 
 beforeTests(runTests);