Add overloading of property descriptors

Author: jonathanKingston

src/features/runtime-checks.js

@@ -2,7 +2,7 @@
 
 import ContentFeature from '../content-feature.js'
 import { DDGProxy, getStackTraceOrigins, getStack, matchHostname, injectGlobalStyles, createStyleElement, postDebugMessage, taintSymbol, hasTaintedMethod, taintedOrigins, getTabHostname, isBeingFramed } from '../utils.js'
-import { defineProperty } from '../wrapper-utils.js'
+import { defineProperty, wrapFunction } from '../wrapper-utils.js'
 import { wrapScriptCodeOverload } from './runtime-checks/script-overload.js'
 import { findClosestBreakpoint } from './runtime-checks/helpers.js'
 import { Reflect } from '../captured-globals.js'
@@ -473,6 +473,86 @@ function isInterrogatingDebugMessage (matchType, matchedStackDomain, stack, scri
     })
 }
 
+function isRuntimeElement (element) {
+    try {
+        return element instanceof DDGRuntimeChecks
+    } catch {}
+    return false
+}
+
+function overloadGetOwnPropertyDescriptor () {
+    const capturedDescriptors = {
+        HTMLScriptElement: Object.getOwnPropertyDescriptors(HTMLScriptElement),
+        HTMLScriptElementPrototype: Object.getOwnPropertyDescriptors(HTMLScriptElement.prototype)
+    }
+    /**
+     * @param {any} value
+     * @returns {string | undefined}
+     */
+    function getInterfaceName (value) {
+        let interfaceName
+        if (value === HTMLScriptElement) {
+            interfaceName = 'HTMLScriptElement'
+        }
+        if (value === HTMLScriptElement.prototype) {
+            interfaceName = 'HTMLScriptElementPrototype'
+        }
+        return interfaceName
+    }
+    // TODO: Consoldiate with wrapProperty code
+    function getInterfaceDescriptor (interfaceValue, interfaceName, propertyName) {
+        const capturedInterface = capturedDescriptors[interfaceName] && capturedDescriptors[interfaceName][propertyName]
+        const capturedInterfaceOut = { ...capturedInterface }
+        if (capturedInterface.get) {
+            capturedInterfaceOut.get = wrapFunction(function () {
+                if (isRuntimeElement(this)) {
+                    return DDGRuntimeChecks[propertyName]
+                }
+                return capturedInterface.get.call(this)
+            }, capturedInterface.get)
+        }
+        if (capturedInterface.set) {
+            capturedInterfaceOut.set = wrapFunction(function (value) {
+                if (isRuntimeElement(this)) {
+                    DDGRuntimeChecks[interfaceName] = value
+                    return
+                }
+                return capturedInterface.set.call(this, [value])
+            }, capturedInterface.set)
+        }
+        return capturedInterfaceOut
+    }
+    const proxy = new DDGProxy(featureName, Object, 'getOwnPropertyDescriptor', {
+        apply (fn, scope, args) {
+            const interfaceValue = args[0]
+            const interfaceName = getInterfaceName(interfaceValue)
+            const propertyName = args[1]
+            const capturedInterface = capturedDescriptors[interfaceName] && capturedDescriptors[interfaceName][propertyName]
+            if (interfaceName && capturedInterface) {
+                return getInterfaceDescriptor(interfaceValue, interfaceName, propertyName)
+            }
+            return Reflect.apply(fn, scope, args)
+        }
+    })
+    proxy.overload()
+    const proxy2 = new DDGProxy(featureName, Object, 'getOwnPropertyDescriptors', {
+        apply (fn, scope, args) {
+            const interfaceValue = args[0]
+            const interfaceName = getInterfaceName(interfaceValue)
+            const capturedInterface = capturedDescriptors[interfaceName]
+            if (interfaceName && capturedInterface) {
+                const out = {}
+                for (const propertyName of Object.getOwnPropertyNames(capturedInterface)) {
+                    out[propertyName] = getInterfaceDescriptor(interfaceValue, interfaceName, propertyName)
+                }
+                return out
+            }
+            return Reflect.apply(fn, scope, args)
+        }
+    })
+    proxy2.overload()
+}
+
 function overrideCreateElement (debug) {
     const proxy = new DDGProxy(featureName, Document.prototype, 'createElement', {
         apply (fn, scope, args) {
@@ -576,6 +656,9 @@ export default class RuntimeChecks extends ContentFeature {
         if (this.getFeatureSettingEnabled('overloadReplaceChild')) {
             overloadReplaceChild()
         }
+        if (this.getFeatureSettingEnabled('overloadGetOwnPropertyDescriptor')) {
+            overloadGetOwnPropertyDescriptor()
+        }
     }
 
     injectGenericOverloads () {

src/wrapper-utils.js

@@ -73,6 +73,33 @@ function wrapToString (newFn, origFn) {
     }
 }
 
+/**
+ * Wrap functions to fix toString but also behave as closely to their real function as possible like .name and .length etc.
+ * TODO: validate with firefox non runtimeChecks context and also consolidate with wrapToString
+ * @param {*} functionValue
+ * @param {*} realTarget
+ * @returns {Proxy} a proxy for the function
+ */
+export function wrapFunction (functionValue, realTarget) {
+    return new Proxy(realTarget, {
+        get (target, prop, receiver) {
+            if (prop === 'toString') {
+                const method = Reflect.get(target, prop, receiver).bind(target)
+                Object.defineProperty(method, 'toString', {
+                    value: functionToString.bind(functionToString),
+                    enumerable: false
+                })
+                return method
+            }
+            return Reflect.get(target, prop, receiver)
+        },
+        apply (target, thisArg, argumentsList) {
+            // This is where we call our real function
+            return Reflect.apply(functionValue, thisArg, argumentsList)
+        }
+    })
+}
+
 /**
  * Wrap a get/set or value property descriptor. Only for data properties. For methods, use wrapMethod(). For constructors, use wrapConstructor().
  * @param {any} object - object whose property we are wrapping (most commonly a prototype)

unit-test/verify-artifacts.js

@@ -6,7 +6,7 @@ import { cwd } from '../scripts/script-utils.js'
 const ROOT = join(cwd(import.meta.url), '..')
 const BUILD = join(ROOT, 'build')
 const APPLE_BUILD = join(ROOT, 'Sources/ContentScopeScripts/dist')
-let CSS_OUTPUT_SIZE = 590_000
+let CSS_OUTPUT_SIZE = 600_000
 const CSS_OUTPUT_SIZE_CHROME = CSS_OUTPUT_SIZE * 1.45 // 45% larger for Chrome MV2 due to base64 encoding
 if (process.platform === 'win32') {
     CSS_OUTPUT_SIZE = CSS_OUTPUT_SIZE * 1.1 // 10% larger for Windows due to line endings