chrome.platformKeys: Require a algorithm name to getKeyPair().

chrome/test/data/extensions/api_test/platform_keys/basic.js

 // Copyright 2015 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.
 
 'use strict';
 
 var systemTokenEnabled = (location.search.indexOf("systemTokenEnabled") != -1);
 var selectedTestSuite = location.hash.slice(1);
 console.log('[SELECTED TEST SUITE] ' + selectedTestSuite +
             ', systemTokenEnable ' + systemTokenEnabled);
@@ skipping 162 matching lines @@
   assertEq('public', publicKey.type);
   assertEq(true, publicKey.extractable);
   checkPropertyIsReadOnly(publicKey, 'algorithm');
   checkAlgorithmIsCopiedOnRead(publicKey);
 }
 
 function testStaticMethods() {
   assertTrue(!!chrome.platformKeys, "No platformKeys namespace.");
   assertTrue(!!chrome.platformKeys.selectClientCertificates,
              "No selectClientCertificates function.");
+  assertTrue(!!chrome.platformKeys.getKeyPair, "No getKeyPair method.");
+  assertTrue(!!chrome.platformKeys.subtleCrypto, "No subtleCrypto getter.");
+  assertTrue(!!chrome.platformKeys.subtleCrypto(), "No subtleCrypto object.");
+  assertTrue(!!chrome.platformKeys.subtleCrypto().sign, "No sign method.");
+  assertTrue(!!chrome.platformKeys.subtleCrypto().exportKey,
+             "No exportKey method.");
   succeed();
 }
 
-function testHasSubtleCryptoMethods(token) {
-  assertTrue(!!token.subtleCrypto.generateKey,
-             "token has no generateKey method");
-  assertTrue(!!token.subtleCrypto.sign, "token has no sign method");
-  assertTrue(!!token.subtleCrypto.exportKey, "token has no exportKey method");
-  succeed();
-}
-
 var requestAll = {
   certificateTypes: [],
   certificateAuthorities: []
 };
 
 // Depends on |data|, thus it cannot be created immediately.
 function requestCA1() {
   return {
     certificateTypes: [],
     certificateAuthorities: [data.client_1_issuer_dn.buffer]
@@ skipping 41 matching lines @@
           name: "RSASSA-PKCS1-v1_5",
           publicExponent: new Uint8Array([0x01, 0x00, 0x01])
         };
         var actualAlgorithm = matches[0].keyAlgorithm;
         assertEq(
             expectedAlgorithm, actualAlgorithm,
             'Member algorithm of Match does not equal the expected algorithm');
       }));
 }
 
+function testGetKeyPairMissingAlgorithName() {
+  var keyParams = {
+    // This is missing the algorithm name.
+    hash: {name: 'SHA-1'}
+  };
+  try {
+    chrome.platformKeys.getKeyPair(
+        data.client_1.buffer, keyParams, function(error) {
+          fail('getKeyPair call was expected to fail.');
+        });
+    fail('getKeyPair did not throw error');
+  } catch (e) {
+    assertEq('Algorithm: name: Missing or not a string', e.message);
+    succeed();
+  }
+}
+
 function testGetKeyPair() {
   var keyParams = {
     // Algorithm names are case-insensitive.
-    'hash': {'name': 'sha-1'}
+    name: 'RSASSA-Pkcs1-V1_5',
+    hash: {name: 'sha-1'}
   };
   chrome.platformKeys.getKeyPair(
       data.client_1.buffer, keyParams,
       callbackPass(function(publicKey, privateKey) {
         var expectedAlgorithm = {
           modulusLength: 2048,
           name: "RSASSA-PKCS1-v1_5",
           publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
           hash: {name: 'SHA-1'}
         };
@@ skipping 10 matching lines @@
                   compareArrays(data.client_1_spki, actualPublicKeySpki) == 0,
                   'Match did not contain correct public key');
             }),
                   function(error) { fail("Export failed: " + error); });
       }));
 }
 
 function testSignNoHash() {
   var keyParams = {
     // Algorithm names are case-insensitive.
+    name: 'RSASSA-PKCS1-V1_5',
     hash: {name: 'NONE'}
   };
   var signParams = {
     name: 'RSASSA-PKCS1-v1_5'
   };
   chrome.platformKeys.getKeyPair(
       data.client_1.buffer, keyParams,
       callbackPass(function(publicKey, privateKey) {
         chrome.platformKeys.subtleCrypto()
             .sign(signParams, privateKey, data.raw_data)
             .then(callbackPass(function(signature) {
               var actualSignature = new Uint8Array(signature);
               assertTrue(compareArrays(data.signature_nohash_pkcs,
                                        actualSignature) == 0,
                          'Incorrect signature');
             }));
       }));
 }
 
 function testSignSha1Client1() {
   var keyParams = {
+    name: 'RSASSA-PKCS1-v1_5',
     // Algorithm names are case-insensitive.
     hash: {name: 'Sha-1'}
   };
   var signParams = {
     // Algorithm names are case-insensitive.
     name: 'RSASSA-Pkcs1-v1_5'
   };
   chrome.platformKeys.getKeyPair(
       data.client_1.buffer, keyParams,
       callbackPass(function(publicKey, privateKey) {
         chrome.platformKeys.subtleCrypto()
             .sign(signParams, privateKey, data.raw_data)
             .then(callbackPass(function(signature) {
               var actualSignature = new Uint8Array(signature);
               assertTrue(
                   compareArrays(data.signature_sha1_pkcs, actualSignature) == 0,
                   'Incorrect signature');
             }));
       }));
 }
 
 // TODO(pneubeck): Test this by verifying that no private key is returned, once
 // that's implemented.
 function testSignFails(cert) {
   var keyParams = {
+    name: 'RSASSA-PKCS1-v1_5',
     hash: {name: 'SHA-1'}
   };
   var signParams = {
     name: 'RSASSA-PKCS1-v1_5'
   };
   chrome.platformKeys.getKeyPair(
       cert.buffer, keyParams, callbackPass(function(publicKey, privateKey) {
         chrome.platformKeys.subtleCrypto()
             .sign(signParams, privateKey, data.raw_data)
             .then(function(signature) { fail('sign was expected to fail.'); },
@@ skipping 18 matching lines @@
   // These tests assume already granted permissions for client_1 and client_2.
   // On interactive selectClientCertificates calls, the simulated user does not
   // select any cert.
   basicTests: function() {
     var tests = [
       testStaticMethods,
       testSelectAllCerts,
       testSelectCA1Certs,
       testInteractiveSelectNoCerts,
       testMatchResult,
+      testGetKeyPairMissingAlgorithName,
       testGetKeyPair,
       testSignNoHash,
       testSignSha1Client1,
     ];
 
     chrome.test.runTests(tests);
   },
 
   // This test suite starts without any granted permissions.
   // On interactive selectClientCertificates calls, the simulated user selects
@@ skipping 21 matching lines @@
       // Verify that client_1 but not client_2 is selected in non-interactive
       // calls.
       testSelectAllReturnsClient1,
     ];
 
     chrome.test.runTests(tests);
   }
 };
 
 setUp(testSuites[selectedTestSuite]);