/content/policy_enforcing.js - Diff - Haketilo - Hydrilla issue tracker

« Previous | Next »

Revision 96efcc33

Added by koszko over 1 year ago

ID 96efcc335bbd9f2ad098e694d6cff6c1c22b4ce8
Parent 70923829
Child 093ec2a5

improve script blocking in non-HTML documents (XML)

     #FROM common/misc.js IMPORT gen_nonce, csp_header_regex
     const html_ns = "http://www.w3.org/1999/xhtml";
     const svg_ns = "http://www.w3.org/2000/svg";
     document.content_loaded = document.readyState === "complete";
     const wait_loaded = e => e.content_loaded ? Promise.resolve() :
           new Promise(c => e.addEventListener("DOMContentLoaded", c, {once: true}));
-...
          */
         if (some_attr_blocked) {
     	const replacement_elem = document.createElement("a");
     	/* Prevent this node from being processed by our observer. */
     	replacement_elem.haketilo_trusted_node = true;
     	element.replaceWith(replacement_elem);
     	replacement_elem.replaceWith(element);
+        }
-...
         element.haketilo_sanitized_onevent = true;
         for (const attribute_node of [...(element.attributes || [])]) {
     	const attr = attribute_node.localName, attr_lo = attr.toLowerCase();;
     	if (!/^on/.test(attr_lo) || !(attr_lo in element.wrappedJSObject))
     	const attr = attribute_node.localName, attr_lo = attr.toLowerCase();
     	if (!/^on/.test(attr_lo) || !(attr_lo in element))
     	    continue;
     	/*
-...
+    }
     #ENDIF
     function start_mo_sanitizing(doc) {
         if (!doc.content_loaded) {
     	function mutation_handler(mutation) {
     	    mutation.addedNodes.forEach(sanitize_element_urls);
     /*
      * Sanitize elements on-the-fly as they appear using MutationObserver.
+     *
      * Under Abrowser 97 it was observed that MutationObserver does not always work
      * as is should. When trying to observe nodes of an XMLDocument the behavior was
      * as if the "subtree" option to MutationObserver.observe() was ignored. To work
      * around this we avoid using the "subtree" option altogether and have the same
      * code work in all scenarios.
      */
     function MOSanitizer(root) {
         this.root = root;
         this.recursively_sanitize(root);
         this.mo = new MutationObserver(ms => this.handle_mutations(ms));
+    }
     MOSanitizer.prototype.observe = function() {
         let elem = this.root;
         while (elem && !elem.haketilo_trusted_node) {
     	this.mo.observe(elem, {childList: true});
     	elem = elem.lastElementChild;
+        }
+    }
     MOSanitizer.prototype.handle_mutations = function(mutations) {
         for (const mut of mutations) {
     	for (const new_node of mut.addedNodes)
     	    this.recursively_sanitize(new_node);
+        }
         this.mo.disconnect();
         this.observe();
+    }
     MOSanitizer.prototype.recursively_sanitize = function(elem) {
         const to_process = [elem];
         while (to_process.length > 0) {
     	const current_elem = to_process.pop();
     	if (current_elem.haketilo_trusted_node ||
     	    current_elem.nodeType !== this.root.ELEMENT_NODE)
     	    continue;
     	to_process.push(...current_elem.children);
     	sanitize_element_urls(current_elem);
     #IF MOZILLA
     	    mutation.addedNodes.forEach(sanitize_element_onevent);
     	sanitize_element_onevent(current_elem);
     #ENDIF
+    	}
     	const mo = new MutationObserver(ms => ms.forEach(mutation_handler));
     	mo.observe(doc, {childList: true, subtree: true});
     	wait_loaded(doc).then(() => mo.disconnect());
+        }
+    }
     MOSanitizer.prototype.start = function() {
         this.recursively_sanitize(this.root);
         this.observe();
+    }
     MOSanitizer.prototype.stop = function() {
         this.mo.disconnect();
+    }
     #IF MOZILLA
     /*
      * Normally, we block scripts with CSP. However, Mozilla does optimizations that
-...
      * applying this CSP to non-inline `<scripts>' in certain scenarios.
      */
     function prevent_script_execution(event) {
         if (!event.target.haketilo_payload)
     	event.preventDefault();
         event.preventDefault();
+    }
     #ENDIF
-...
      * javascript execution.
      */
     async function sanitize_document(doc, policy) {
         const root = doc.documentElement;
         const substitute_doc =
     	  new DOMParser().parseFromString("<!DOCTYPE html>", "text/html");
     #IF MOZILLA
         /*
          * Blocking of scripts that are in the DOM from the beginning. Needed for
          * Mozilla.
          */
         const listener_args = ["beforescriptexecute", prevent_script_execution];
         doc.addEventListener(...listener_args);
         substitute_doc.addEventListener(...listener_args);
         wait_loaded(doc).then(() => doc.removeEventListener(...listener_args));
         sanitize_tree_urls(doc.documentElement);
         sanitize_tree_onevent(doc.documentElement);
     #ENDIF
         if (!doc.content_loaded) {
     	const sanitizer = new MOSanitizer(doc.documentElement);
     	sanitizer.start();
     	wait_loaded(doc).then(() => sanitizer.stop());
+        }
         /*
          * Ensure our CSP rules are employed from the beginning. This CSP injection
          * method is, when possible, going to be applied together with CSP rules
-...
          * Root node gets hijacked now, to be re-attached after <head> is loaded
          * and sanitized.
          */
         const root = doc.documentElement;
         root.replaceWith(temporary_html);
     #IF MOZILLA
         /*
          * To be able to handle the onbeforescriptexecute event for scripts that
          * appear under detached document.
          */
         substitute_doc.documentElement.replaceWith(root);
     #ENDIF
         /*
          * When we don't inject payload, we neither block document's CSP `<meta>'
-...
     	    .forEach(m => sanitize_meta(m, policy));
+        }
         sanitize_tree_urls(root);
         root.querySelectorAll("script").forEach(s => sanitize_script(s, policy));
         const scripts = [...root.getElementsByTagNameNS(html_ns, "script"),
     		     ...root.getElementsByTagNameNS(svg_ns, "svg")];
         scripts.forEach(s => sanitize_script(s, policy));
         temporary_html.replaceWith(root);
         root.querySelectorAll("script").forEach(s => desanitize_script(s, policy));
     #IF MOZILLA
         sanitize_tree_onevent(root);
     #ENDIF
         start_mo_sanitizing(doc);
         scripts.forEach(s => desanitize_script(s, policy));
+    }
     async function _disable_service_workers() {

Also available in: Unified diff