Issue 6969 - Implement abort-on-property-read snippet

lib/content/snippets.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 473 matching lines @@
     if ((!selector || target.matches(selector)) &&
         (!re || re.test(target.textContent)))
     {
       event.preventDefault();
     }
   },
   true);
 }
 
 exports["prevent-inline-scripts"] = preventInlineScripts;
+
+/**
+ * Generates a random alphanumeric ID consisting of 6 base-36 digits
+ * from the range 100000..zzzzzz (both inclusive).
+ *
+ * @returns {string} The random ID.
+ */
+function randomId()
+{
+  // 2176782336 is 36^6 which mean 6 chars [a-z0-9]
+  // 60466176 is 36^5
+  // 2176782336 - 60466176 = 2116316160. This ensure to always have 6
+  // chars even if Math.random() returns its minimum value 0.0
+  //
+  return Math.floor(Math.random() * 2116316160 + 60466176).toString(36);
+}
+
+function wrapPropertyAccess(object, property, descriptor)
+{
+  let currentDescriptor = Object.getOwnPropertyDescriptor(object, property);
+  if (!currentDescriptor)
+  {

[Manish Jethani, 2018/10/30 22:57:28]

OK, so here's the thing: We don't need to use the previous descriptor at all.
The new descriptor can only overwrite the properties given in the descriptor,
any other properties are not overwritten.

For example:

  let obj = {};

  Object.defineProperty(obj, "foo", {value: 1, writable: true, configurable:
true});
  Object.defineProperty(obj, "foo", {get: function(){return 2}});
  Object.defineProperty(obj, "foo", {configurable: false});

  console.log(Object.getOwnPropertyDescriptor(obj, "foo"));

  console.log(obj.foo);

But also note that we can't redefine a property that isn't configurable, so we
need to check that:

  if (currentDescriptor && !currentDescriptor.configurable)
    return false;

Other than this, we can just remove everything else and go straight to the last
line.

Also I think this function should return true if it wrapped the property and
false otherwise, so that if the property wasn't wrapped then the calling code
can skip some other stuff (like adding a onerror handler).

[hub, 2018/10/31 16:35:48]

Done.

+    if (typeof descriptor.get == "undefined")
+      descriptor.get = currentDescriptor.get;
+    if (typeof descriptor.set == "undefined")
+      descriptor.set = currentDescriptor.set;
+  }
+  Object.defineProperty(object, property, descriptor);
+}
+
+/**
+ * Patches a property on the window object to abort execution when the
+ * property is read.
+ * No error will be printed in the console.
+ * The idea originates from
+ * {@link https://github.com/uBlockOrigin/uAssets/blob/80b195436f8f8d78ba713237bfc268ecfc9d9d2b/filters/resources.txt#L1703 uBlock Origin}
+ *
+ * @param {string} property The name of the property.
+ */
+function abortOnPropertyRead(property)
+{
+  if (!property)
+    return;
+
+  let rid = randomId();
+
+  function abort()
+  {
+    throw new ReferenceError(rid);
+  }
+
+  let {onerror} = window;
+  window.onerror = (message, ...rest) =>
+  {
+    if (typeof message == "string" && message.includes(rid))
+      return true;
+    if (typeof onerror == "function")
+      return (() => {}).call.call(onerror, this, message, ...rest);
+  };
+
+  wrapPropertyAccess(window, property, {get: abort, set() {}});
+}
+
+exports["abort-on-property-read"] = makeInjector(abortOnPropertyRead,
+                                                 wrapPropertyAccess,
+                                                 randomId);