enterprise.platformKeys: Respect the 'hash' argument of generateKey.

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 84 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();
     }
 
+    // normalizeAlgorithm returns an array, but publicExponent should be a
+    // Uint8Array.
+    normalizedAlgorithmParameters.publicExponent =
+        new Uint8Array(normalizedAlgorithmParameters.publicExponent);
+
     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) {
         reject(CreateOperationError());
         return;
       }
-      resolve(new KeyPair(spki, algorithm, keyUsages));
+      resolve(new KeyPair(spki, normalizedAlgorithmParameters, keyUsages));
     });
   });
 };
 
 SubtleCryptoImpl.prototype.sign = function(algorithm, key, dataView) {
   var subtleCrypto = this;
   return new Promise(function(resolve, reject) {
     if (key.type != 'private' || key.usages.indexOf(KeyUsage.sign) == -1)
       throw CreateInvalidAccessError();
 
     var normalizedAlgorithmParameters =
         normalizeAlgorithm(algorithm, 'Sign');
     if (!normalizedAlgorithmParameters) {
       // TODO(pneubeck): It's not clear from the WebCrypto spec which error to
       // throw here.
       throw CreateSyntaxError();
     }
 
     // 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, getSpki(key), data, function(signature) {
-          if (catchInvalidTokenError(reject))
-            return;
-          if (chrome.runtime.lastError) {
-            reject(CreateOperationError());
-            return;
-          }
-          resolve(signature);
-        });
+    internalAPI.sign(subtleCrypto.tokenId,
+                     getSpki(key),
+                     key.algorithm.hash.name,
+                     data,
+                     function(signature) {
+      if (catchInvalidTokenError(reject))
+        return;
+      if (chrome.runtime.lastError) {
+        reject(CreateOperationError());
+        return;
+      }
+      resolve(signature);
+    });
   });
 };
 
 SubtleCryptoImpl.prototype.exportKey = function(format, key) {
   return new Promise(function(resolve, reject) {
     if (format == 'pkcs8') {
       // Either key.type is not 'private' or the key is not extractable. In both
       // cases the error is the same.
       throw CreateInvalidAccessError();
     } else if (format == 'spki') {
       if (key.type != 'public')
         throw CreateInvalidAccessError();
       resolve(getSpki(key));
     } else {
       // TODO(pneubeck): It should be possible to export to format 'jwk'.
       throw CreateNotSupportedError();
     }
   });
 };
 
 exports.SubtleCrypto =
     utils.expose('SubtleCrypto',
                  SubtleCryptoImpl,
                  {functions:['generateKey', 'sign', 'exportKey']});