enterprise.platformKeys: Copy-on-read the 'algorithm' member of Key objects.

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 .
 
 'use strict';
 
 var assertEq = chrome.test.assertEq;
@@ skipping 242 matching lines @@
   getUserToken(function(userToken) {
     if (!userToken)
       fail('no user token');
     if (userToken.id != 'user')
       fail('token is not named "user".');
 
     callback(userToken);
   });
 }
 
+function checkAlgorithmIsCopiedOnRead(key) {
+  var algorithm = key.algorithm;
+  var originalAlgorithm = {
+    name: algorithm.name,
+    modulusLength: algorithm.modulusLength,
+    publicExponent: algorithm.publicExponent,
+    hash: {name: algorithm.hash.name}
+  };
+  var originalModulusLength = algorithm.modulusLength;
+  algorithm.hash.name = null;
+  algorithm.hash = null;
+  algorithm.name = null;
+  algorithm.modulusLength = null;
+  algorithm.publicExponent = null;
+  assertEq(originalAlgorithm, key.algorithm);
+}
+
+function checkPropertyIsReadOnly(object, key) {
+  var original = object[key];
+  try {
+    object[key] = {};
+    fail('Expected that the property is read only and an exception to ' +

[bartfab (slow), 2014/06/18 16:19:06]

Nit: Grammar: "Expected the property to be read-only and an exception to be
thrown."

+         'be thrown');
+  } catch (error) {
+    assertEq(original, object[key]);
+  }
+}
+
+function checkKeyPairCommonFormat(keyPair) {
+  checkPropertyIsReadOnly(keyPair, 'privateKey');
+  var privateKey = keyPair.privateKey;
+  assertEq('private', privateKey.type);
+  assertEq(false, privateKey.extractable);
+  checkPropertyIsReadOnly(privateKey, 'algorithm');
+  checkAlgorithmIsCopiedOnRead(privateKey);
+
+  checkPropertyIsReadOnly(keyPair, 'publicKey');
+  var publicKey = keyPair.publicKey;
+  assertEq('public', publicKey.type);
+  assertEq(true, publicKey.extractable);
+  checkPropertyIsReadOnly(publicKey, 'algorithm');
+  checkAlgorithmIsCopiedOnRead(publicKey);
+}
+
 function runTests(userToken) {
   chrome.test.runTests([
     function hasSubtleCryptoMethods() {
       assertTrue(!!userToken.subtleCrypto.generateKey,
                  "user token has no generateKey method");
       assertTrue(!!userToken.subtleCrypto.sign,
                  "user token has no sign method");
       assertTrue(!!userToken.subtleCrypto.exportKey,
                  "user token has no exportKey method");
       succeed();
@@ skipping 28 matching lines @@
       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) { fail("GenerateKey failed: " + error); })
           .then(callbackPass(function(publicKeySpki) {
                   // Ensure that the returned key pair has the expected format.
+                  // Some parameter independent checks:
+                  checkKeyPairCommonFormat(cachedKeyPair);
+
                   // Checks depending on the generateKey arguments:
                   var privateKey = cachedKeyPair.privateKey;
                   assertEq(['sign'], privateKey.usages);
                   assertEq(algorithm, privateKey.algorithm);
 
                   var publicKey = cachedKeyPair.publicKey;
                   assertEq([], publicKey.usages);
                   assertEq(algorithm, publicKey.algorithm);
 
                   cachedSpki = publicKeySpki;
@@ skipping 151 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);