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

chrome/renderer/resources/extensions/enterprise_platform_keys/key.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');
 
 /**
  * Enum of possible key types (subset of WebCrypto.KeyType).
  * @enum {string}
  */
 var KeyType = {
   public: 'public',
   private: 'private'
 };
 
 /**
  * Enum of possible key usages (subset of WebCrypto.KeyUsage).
  * @enum {string}
  */
 var KeyUsage = {
   sign: 'sign',
   verify: 'verify'
 };
 
+// Freezes |object| recursively. |object| must not contain cyclic references.
+// TODO(pneubeck): Freeze Uint8Arrays (currently used for the publicExponent
+//   only) also, once V8 supports it.
+function deepFreeze(object) {
+  if (Object.isFrozen(object))
+    return;
+  Object.freeze(object);
+  for (var key in object) {
+    var prop = object[key];
+    if (!object.hasOwnProperty(key) || (typeof prop) !== 'object' ||
+        prop.__proto__.constructor.name === 'Uint8Array') {
+      continue;
+    }
+    deepFreeze(prop);
+  }
+}
+
 /**
  * Implementation of WebCrypto.Key used in enterprise.platformKeys.
  * @param {KeyType} type The type of the new key.
  * @param {ArrayBuffer} publicKeySpki The Subject Public Key Info in DER
  *   encoding.
  * @param {KeyAlgorithm} algorithm The algorithm identifier.
  * @param {KeyUsage[]} usages The allowed key usages.
  * @param {boolean} extractable Whether the key is extractable.
  * @constructor
  */
 var KeyImpl = function(type, publicKeySpki, algorithm, usages, extractable) {
   this.type = type;
   this.spki = publicKeySpki;
   this.algorithm = algorithm;
+  deepFreeze(this.algorithm);

[not at google - send to devlin, 2014/06/16 17:58:32]

why do you need this? the way that you're exposing Key, with {readonly:
['algorithm']}, should prevent it from being modified. or am I missing
something?

also I don't know what part of this test is functional and what part is test
cleanup.

[pneubeck (no reviews), 2014/06/16 18:01:18]

algorithm is an Object and defineProperty doesn't prevent modifying nested
properties. It only prevents assign another object to the member 'algorithm' of
the Key object.
Sorry. I'll separate it into two CLs.

[not at google - send to devlin, 2014/06/16 18:08:31]

ah right. "deepFreeze" is a great name.

I find it a little odd that a sideeffect of constructing a KeyImpl is to freeze
an object that it's given. Better to either ensure that the algorithm can't be
modified from outside the function (i.e. that an unmodifiable algorithm is
passed in) or KeyImpl should make a copy of it.

   this.usages = usages;
   this.extractable = extractable;
 };
 
 var Key =
     utils.expose('Key',
                  KeyImpl,
                  {readonly:['extractable', 'type', 'algorithm', 'usages']});
 
 /**
  * Returns |key|'s Subject Public Key Info. Throws an exception if |key| is not
  * a valid Key object.
  * @param {Key} key
  * @return {ArrayBuffer} The Subject Public Key Info in DER encoding of |key|.
  */
 function getSpki(key) {
   if (!privates(key))
     throw new Error('Invalid key object.');
   var keyImpl = privates(key).impl;
   if (!keyImpl || !keyImpl.spki)
     throw new Error('Invalid key object.');
   return keyImpl.spki;
 }
 
 exports.Key = Key;
 exports.KeyType = KeyType;
 exports.KeyUsage = KeyUsage;
 exports.getSpki = getSpki;