From 014f2a2f4e2071c35314d67285711f0f4615266b Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Wed, 18 Aug 2021 17:53:57 +0200
Subject: implement smuggling via cookies instead of URL

---
 content/main.js | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'content/main.js')

diff --git a/content/main.js b/content/main.js
index 9ed557c..8adcd48 100644
--- a/content/main.js
+++ b/content/main.js
@@ -9,8 +9,7 @@
 /*
  * IMPORTS_START
  * IMPORT handle_page_actions
- * IMPORT url_extract_target
- * IMPORT gen_unique
+ * IMPORT extract_signed
  * IMPORT gen_nonce
  * IMPORT csp_rule
  * IMPORT is_privileged_url
@@ -98,18 +97,21 @@ function inject_csp(head)
 }
 
 if (!is_privileged_url(document.URL)) {
-    const targets = url_extract_target(document.URL);
-    if (targets.policy) {
-	if (targets.target2)
-	    window.location.href = targets.base_url + targets.target2;
-	else
-	    history.replaceState(null, "", targets.base_url);
+    const reductor =
+	  (ac, [_, sig, pol]) => ac[0] && ac || [extract_signed(sig, pol), sig];
+    const matches = [...document.cookie.matchAll(/hachette-(\w*)=([^;]*)/g)];
+    let [policy, signature] = matches.reduce(reductor, []);
+
+    console.log("extracted policy", [signature, policy]);
+    if (!policy || policy.url !== document.URL) {
+	console.log("using default policy");
+	policy = {allow: false, nonce: gen_nonce()};
     }
 
-    const policy = targets.current ? targets.policy : {};
+    if (signature)
+	document.cookie = `hachette-${signature}=; Max-Age=-1;`;
 
-    nonce = policy.nonce || gen_nonce();
-    handle_page_actions(nonce);
+    handle_page_actions(policy.nonce);
 
     if (!policy.allow) {
 	block_nodes_recursively(document.documentElement);
-- 
cgit v1.2.3


From 3d0efa153c95f3bf4912379f910bc59d0fd563c9 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Wed, 18 Aug 2021 20:54:07 +0200
Subject: remove unneeded policy-related cosole messages; restore IceCat 60
 compatibility

---
 background/policy_injector.js |  3 +--
 build.sh                      | 19 +++++++++++++++++--
 common/misc.js                |  2 +-
 content/main.js               |  5 +----
 4 files changed, 20 insertions(+), 9 deletions(-)

(limited to 'content/main.js')

diff --git a/background/policy_injector.js b/background/policy_injector.js
index 947812e..702f879 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -33,7 +33,6 @@ const report_only = "content-security-policy-report-only";
 
 function headers_inject(details)
 {
-    console.log("ijnector details", details);
     const url = details.url;
     if (is_privileged_url(url))
 	return;
@@ -70,7 +69,7 @@ function headers_inject(details)
 	headers.push(hachette_header);
     }
 
-    orig_csp_headers ||=
+    orig_csp_headers = orig_csp_headers ||
 	headers.filter(h => csp_header_names.has(h.name.toLowerCase()));
     headers = headers.filter(h => !csp_header_names.has(h.name.toLowerCase()));
 
diff --git a/build.sh b/build.sh
index 941ce1e..31f3dec 100755
--- a/build.sh
+++ b/build.sh
@@ -267,9 +267,24 @@ $(map_get EXPORTCODES $FILEKEY)
     done
 
     if [ "$BROWSER" = "chromium" ]; then
-	echo "window.killtheweb={is_chrome: true, browser: window.chrome};" > $BUILDDIR/exports_init.js
+	cat > $BUILDDIR/exports_init.js <<EOF
+window.killtheweb={is_chrome: true, browser: window.chrome};
+EOF
     else
-	echo "window.killtheweb={is_mozilla: true, browser: this.browser};" > $BUILDDIR/exports_init.js
+	cat > $BUILDDIR/exports_init.js <<EOF
+/* Polyfill for IceCat 60. */
+String.prototype.matchAll = String.prototype.matchAll || function(regex) {
+    if (regex.flags.search("g") === -1)
+        throw new TypeError("String.prototype.matchAll called with a non-global RegExp argument");
+
+    for (const matches = [];;) {
+        if (matches[matches.push(regex.exec(this)) - 1] === null)
+	    return matches.splice(0, matches.length - 1);
+    }
+}
+
+window.killtheweb={is_mozilla: true, browser: this.browser};
+EOF
     fi
 
     cp -r copyright licenses/ $BUILDDIR
diff --git a/common/misc.js b/common/misc.js
index 39c696f..6e825d6 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -56,7 +56,7 @@ function get_secure_salt()
 function extract_signed(signature, data, times)
 {
     const now = new Date();
-    times ||= [[now], [now, -1]];
+    times = times || [[now], [now, -1]];
 
     const reductor =
 	  (ok, time) => ok || signature === sign_data(data, ...time);
diff --git a/content/main.js b/content/main.js
index 8adcd48..164ebe3 100644
--- a/content/main.js
+++ b/content/main.js
@@ -84,8 +84,6 @@ function block_script(node)
 
 function inject_csp(head)
 {
-    console.log('injecting CSP');
-
     let meta = document.createElement("meta");
     meta.setAttribute("http-equiv", "Content-Security-Policy");
     meta.setAttribute("content", csp_rule(nonce));
@@ -102,9 +100,8 @@ if (!is_privileged_url(document.URL)) {
     const matches = [...document.cookie.matchAll(/hachette-(\w*)=([^;]*)/g)];
     let [policy, signature] = matches.reduce(reductor, []);
 
-    console.log("extracted policy", [signature, policy]);
     if (!policy || policy.url !== document.URL) {
-	console.log("using default policy");
+	console.log("WARNING! Using default policy!!!");
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
-- 
cgit v1.2.3


From d09b7ee10541b5a81430d2e11abb3a9a09643ade Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Fri, 20 Aug 2021 12:57:48 +0200
Subject: sanitize `<meta>' tags containing CSP rules under Chromium

This commit adds a mechanism of hijacking document when it loads and injecting sanitized nodes to the DOM from the level of content script.
---
 background/policy_injector.js |  23 ++---
 common/misc.js                |  27 +++++-
 content/main.js               |  99 ++++----------------
 content/sanitize_document.js  | 209 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 256 insertions(+), 102 deletions(-)
 create mode 100644 content/sanitize_document.js

(limited to 'content/main.js')

diff --git a/background/policy_injector.js b/background/policy_injector.js
index 702f879..3398b53 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -18,19 +18,12 @@
  * IMPORT query_best
  * IMPORT sanitize_csp_header
  * IMPORT csp_rule
+ * IMPORT is_csp_header_name
  * IMPORTS_END
  */
 
 var storage;
 
-const csp_header_names = new Set([
-    "content-security-policy",
-    "x-webkit-csp",
-    "x-content-security-policy"
-]);
-
-const report_only = "content-security-policy-report-only";
-
 function headers_inject(details)
 {
     const url = details.url;
@@ -40,7 +33,6 @@ function headers_inject(details)
     const [pattern, settings] = query_best(storage, url);
     const allow = !!(settings && settings.allow);
     const nonce = gen_nonce();
-    const rule = `'nonce-${nonce}'`;
 
     let orig_csp_headers;
     let old_signature;
@@ -70,20 +62,19 @@ function headers_inject(details)
     }
 
     orig_csp_headers = orig_csp_headers ||
-	headers.filter(h => csp_header_names.has(h.name.toLowerCase()));
-    headers = headers.filter(h => !csp_header_names.has(h.name.toLowerCase()));
+	headers.filter(h => is_csp_header_name(h.name));
 
-    /* Remove headers that only snitch on us */
-    if (!allow)
-	headers = headers.filter(h => h.name.toLowerCase() !== report_only);
+    /* When blocking remove report-only CSP headers that snitch on us. */
+    headers = headers.filter(h => !is_csp_header_name(h.name, !allow));
 
     if (old_signature)
 	headers = headers.filter(h => h.name.search(old_signature) === -1);
 
-    const sanitizer = h => sanitize_csp_header(h, rule, allow);
+    const policy_object = {allow, nonce, url};
+    const sanitizer = h => sanitize_csp_header(h, policy_object);
     headers.push(...orig_csp_headers.map(sanitizer));
 
-    const policy = encodeURIComponent(JSON.stringify({allow, nonce, url}));
+    const policy = encodeURIComponent(JSON.stringify(policy_object));
     const policy_signature = sign_data(policy, new Date());
     const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
     headers.push({
diff --git a/common/misc.js b/common/misc.js
index 6e825d6..8894d60 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -78,6 +78,23 @@ function csp_rule(nonce)
     return `script-src ${rule}; script-src-elem ${rule}; script-src-attr 'none'; prefetch-src 'none';`;
 }
 
+/* Check if some HTTP header might define CSP rules. */
+const csp_header_names = new Set([
+    "content-security-policy",
+    "x-webkit-csp",
+    "x-content-security-policy"
+]);
+
+const report_only_header_name = "content-security-policy-report-only";
+
+function is_csp_header_name(string, include_report_only)
+{
+    string = string && string.toLowerCase() || "";
+
+    return (include_report_only && string === report_only_header_name) ||
+	csp_header_names.has(string);
+}
+
 /*
  * Print item together with type, e.g.
  * nice_name("s", "hello") → "hello (script)"
@@ -127,11 +144,12 @@ function parse_csp(csp) {
 }
 
 /* Make CSP headers do our bidding, not interfere */
-function sanitize_csp_header(header, rule, allow)
+function sanitize_csp_header(header, policy)
 {
+    const rule = `'nonce-${policy.nonce}'`;
     const csp = parse_csp(header.value);
 
-    if (!allow) {
+    if (!policy.allow) {
 	/* No snitching */
 	delete csp['report-to'];
 	delete csp['report-uri'];
@@ -153,11 +171,11 @@ function sanitize_csp_header(header, rule, allow)
     else
 	csp['script-src-elem'] = [rule];
 
-    const new_policy = Object.entries(csp).map(
+    const new_csp = Object.entries(csp).map(
 	i => `${i[0]} ${i[1].join(' ')};`
     );
 
-    return {name: header.name, value: new_policy.join('')};
+    return {name: header.name, value: new_csp.join('')};
 }
 
 /* Regexes and objest to use as/in schemas for parse_json_with_schema(). */
@@ -178,6 +196,7 @@ const matchers = {
  * EXPORT extract_signed
  * EXPORT sign_data
  * EXPORT csp_rule
+ * EXPORT is_csp_header_name
  * EXPORT nice_name
  * EXPORT open_in_settings
  * EXPORT is_privileged_url
diff --git a/content/main.js b/content/main.js
index 164ebe3..441636c 100644
--- a/content/main.js
+++ b/content/main.js
@@ -11,87 +11,24 @@
  * IMPORT handle_page_actions
  * IMPORT extract_signed
  * IMPORT gen_nonce
- * IMPORT csp_rule
  * IMPORT is_privileged_url
- * IMPORT sanitize_attributes
  * IMPORT mozilla_suppress_scripts
  * IMPORT is_chrome
  * IMPORT is_mozilla
  * IMPORT start_activity_info_server
+ * IMPORT modify_on_the_fly
  * IMPORTS_END
  */
 
-/*
- * Due to some technical limitations the chosen method of whitelisting sites
- * is to smuggle whitelist indicator in page's url as a "magical" string
- * after '#'. Right now this is only supplemental in HTTP(s) pages where
- * blocking of native scripts also happens through CSP header injection but is
- * necessary for protocols like ftp:// and file://.
- *
- * The code that actually injects the magical string into ftp:// and file://
- * urls has not yet been added to the extension.
- */
-
-var nonce = undefined;
-
-function handle_mutation(mutations, observer)
-{
-    if (document.readyState === 'complete') {
-	console.log("mutation handling complete");
-	observer.disconnect();
-	return;
-    }
-    for (const mutation of mutations) {
-	for (const node of mutation.addedNodes)
-	    block_node(node);
-    }
-}
-
-function block_nodes_recursively(node)
-{
-    block_node(node);
-    for (const child of node.children)
-	block_nodes_recursively(child);
-}
-
-function block_node(node)
+function accept_node(node, parent)
 {
+    const clone = document.importNode(node, false);
+    node.hachette_corresponding = clone;
     /*
-     * Modifying <script> element doesn't always prevent its execution in some
-     * Mozilla browsers. This is Chromium-specific code.
+     * TODO: Stop page's own issues like "Error parsing a meta element's
+     * content:" from appearing as extension's errors.
      */
-    if (node.tagName === "SCRIPT") {
-	block_script(node);
-	return;
-    }
-
-    sanitize_attributes(node);
-
-    if (node.tagName === "HEAD")
-	inject_csp(node);
-}
-
-function block_script(node)
-{
-    /*
-     * Disabling scripts this way allows them to still be relatively
-     * easily accessed in case they contain some useful data.
-     */
-    if (node.hasAttribute("type"))
-	node.setAttribute("blocked-type", node.getAttribute("type"));
-    node.setAttribute("type", "application/json");
-}
-
-function inject_csp(head)
-{
-    let meta = document.createElement("meta");
-    meta.setAttribute("http-equiv", "Content-Security-Policy");
-    meta.setAttribute("content", csp_rule(nonce));
-
-    if (head.firstElementChild === null)
-	head.appendChild(meta);
-    else
-	head.insertBefore(meta, head.firstElementChild);
+    parent.hachette_corresponding.appendChild(clone);
 }
 
 if (!is_privileged_url(document.URL)) {
@@ -110,20 +47,18 @@ if (!is_privileged_url(document.URL)) {
 
     handle_page_actions(policy.nonce);
 
-    if (!policy.allow) {
-	block_nodes_recursively(document.documentElement);
+    if (!policy.allow && is_mozilla)
+	addEventListener('beforescriptexecute', mozilla_suppress_scripts, true);
 
-	if (is_chrome) {
-	    var observer = new MutationObserver(handle_mutation);
-	    observer.observe(document.documentElement, {
-		attributes: true,
-		childList: true,
-		subtree: true
-	    });
-	}
+    if (!policy.allow && is_chrome) {
+	const old_html = document.documentElement;
+	const new_html = document.createElement("html");
+	old_html.replaceWith(new_html);
+	old_html.hachette_corresponding = new_html;
 
-	if (is_mozilla)
-	    addEventListener('beforescriptexecute', mozilla_suppress_scripts, true);
+	const modify_end =
+	      modify_on_the_fly(old_html, policy, {node_eater: accept_node});
+	document.addEventListener("DOMContentLoaded", modify_end);
     }
 
     start_activity_info_server();
diff --git a/content/sanitize_document.js b/content/sanitize_document.js
new file mode 100644
index 0000000..1533526
--- /dev/null
+++ b/content/sanitize_document.js
@@ -0,0 +1,209 @@
+/**
+ * Hachette modify HTML document as it loads and reconstruct HTML code from it
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * IMPORTS_START
+ * IMPORT gen_nonce
+ * IMPORT csp_rule
+ * IMPORT is_csp_header_name
+ * IMPORT sanitize_csp_header
+ * IMPORT sanitize_attributes
+ * IMPORTS_END
+ */
+
+/*
+ * Functions that sanitize elements. The script blocking measures are, when
+ * possible, going to be applied together with CSP rules injected using
+ * webRequest.
+ */
+
+const blocked = "blocked";
+
+function block_attribute(node, attr)
+{
+    /*
+     * Disabling attributed this way allows them to still be relatively
+     * easily accessed in case they contain some useful data.
+     */
+
+    const construct_name = [attr];
+    while (node.hasAttribute(construct_name.join("")))
+	construct_name.unshift(blocked);
+
+    while (construct_name.length > 1) {
+	construct_name.shift();
+	const name = construct_name.join("");
+	node.setAttribute(`${blocked}-${name}`, node.getAttribute(name));
+    }
+
+    node.removeAttribute(attr);
+}
+
+function sanitize_script(script, policy)
+{
+    if (policy.allow)
+	return;
+
+    block_attribute(script, "type");
+    script.setAttribute("type", "application/json");
+}
+
+function inject_csp(head, policy)
+{
+    if (policy.allow)
+	return;
+
+    const meta = document.createElement("meta");
+    meta.setAttribute("http-equiv", "Content-Security-Policy");
+    meta.setAttribute("content", csp_rule(policy.nonce));
+    meta.hachette_ignore = true;
+    head.prepend(meta);
+}
+
+function sanitize_http_equiv_csp_rule(meta, policy)
+{
+    const http_equiv = meta.getAttribute("http-equiv");
+
+    if (!is_csp_header_name(http_equiv, !policy.allow))
+	return;
+
+    if (policy.allow || is_csp_header_name(http_equiv, false)) {
+	let value = meta.getAttribute("content");
+	block_attribute(meta, "content");
+	if (value) {
+	    value = sanitize_csp_header({value}, policy).value;
+	    meta.setAttribute("content", value);
+	}
+	return;
+    }
+
+    block_attribute(meta, "http-equiv");
+}
+
+function sanitize_node(node, policy)
+{
+    if (node.tagName === "SCRIPT")
+	sanitize_script(node, policy);
+
+    if (node.tagName === "HEAD")
+	inject_csp(node, policy);
+
+    if (node.tagName === "META")
+	sanitize_http_equiv_csp_rule(node, policy);
+
+    if (!policy.allow)
+	sanitize_attributes(node, policy);
+}
+
+const serializer = new XMLSerializer();
+
+function start_node(node, data)
+{
+    if (!data.writer)
+	return;
+
+    node.hachette_started = true;
+    const clone = node.cloneNode(false);
+    clone.textContent = data.uniq;
+    data.writer(data.uniq_reg.exec(clone.outerHTML)[1]);
+}
+
+function finish_node(node, data)
+{
+    const nodes_to_process = [node];
+
+    while (true) {
+	node = nodes_to_process.pop();
+	if (!node)
+	    break;
+
+	nodes_to_process.push(node, node.hachette_last_added);
+    }
+
+    while (nodes_to_process.length > 0) {
+	const node = nodes_to_process.pop();
+	node.remove();
+
+	if (!data.writer)
+	    continue;
+
+	if (node.hachette_started) {
+	    node.textContent = data.uniq;
+	    data.writer(data.uniq_reg.exec(node.outerHTML)[2]);
+	    continue;
+	}
+
+	data.writer(node.outerHTML || serializer.serializeToString(node));
+    }
+}
+
+/*
+ * Important! Due to some weirdness node.parentElement is not alway correct
+ * under Chromium. Track node relations manually.
+ */
+function handle_added_node(node, true_parent, data)
+{
+    if (node.hachette_ignore || true_parent.hachette_ignore)
+	return;
+
+    if (!true_parent.hachette_started)
+	start_node(true_parent, data)
+
+    sanitize_node(node, data.policy);
+
+    if (data.node_eater)
+	data.node_eater(node, true_parent);
+
+    finish_node(true_parent.hachette_last_added, data);
+
+    true_parent.hachette_last_added = node;
+}
+
+function handle_mutation(mutations, data)
+{
+    /*
+     * Chromium: for an unknown reason mutation.target is not always the same as
+     * node.parentElement. The former is the correct one.
+     */
+    for (const mutation of mutations) {
+	for (const node of mutation.addedNodes)
+	    handle_added_node(node, mutation.target, data);
+    }
+}
+
+function finish_processing(data)
+{
+    handle_mutation(data.observer.takeRecords(), data);
+    finish_node(data.html_element, data);
+    data.observer.disconnect();
+}
+
+function modify_on_the_fly(html_element, policy, consumers)
+{
+    const uniq = gen_nonce();
+    const uniq_reg = new RegExp(`^(.*)${uniq}(.*)$`);
+    const data = {policy, html_element, uniq, uniq_reg, ...consumers};
+
+    start_node(data.html_element, data);
+
+    var observer = new MutationObserver(m => handle_mutation(m, data));
+    observer.observe(data.html_element, {
+     	attributes: true,
+	childList: true,
+	subtree: true
+    });
+
+    data.observer = observer;
+
+    return () => finish_processing(data);
+}
+
+/*
+ * EXPORTS_START
+ * EXPORT modify_on_the_fly
+ * EXPORTS_END
+ */
-- 
cgit v1.2.3


From 6b53d6c840140fc5df6d7638808b978d96502a35 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Mon, 23 Aug 2021 11:05:51 +0200
Subject: use StreamFilter under Mozilla to prevent csp <meta> tags from
 blocking our injected scripts

---
 background/main.js            |  60 ++++++++++-
 background/policy_injector.js |  61 +++--------
 background/stream_filter.js   | 176 ++++++++++++++++++++++++++++++++
 content/main.js               |   5 +-
 content/sanitize_document.js  | 229 +++++++++++++++++++++++++++++++++---------
 copyright                     |   7 ++
 6 files changed, 437 insertions(+), 101 deletions(-)
 create mode 100644 background/stream_filter.js

(limited to 'content/main.js')

diff --git a/background/main.js b/background/main.js
index 7c50fd5..85f8ce8 100644
--- a/background/main.js
+++ b/background/main.js
@@ -11,18 +11,21 @@
  * IMPORT get_storage
  * IMPORT start_storage_server
  * IMPORT start_page_actions_server
- * IMPORT start_policy_injector
  * IMPORT browser
+ * IMPORT is_privileged_url
+ * IMPORT query_best
+ * IMPORT gen_nonce
+ * IMPORT inject_csp_headers
+ * IMPORT apply_stream_filter
+ * IMPORT is_chrome
  * IMPORTS_END
  */
 
 start_storage_server();
 start_page_actions_server();
-start_policy_injector();
 
 async function init_ext(install_details)
 {
-    console.log("details:", install_details);
     if (install_details.reason != "install")
 	return;
 
@@ -44,4 +47,53 @@ async function init_ext(install_details)
 
 browser.runtime.onInstalled.addListener(init_ext);
 
-console.log("hello, hachette");
+
+let storage;
+
+function on_headers_received(details)
+{
+    const url = details.url;
+    if (is_privileged_url(details.url))
+	return;
+
+    const [pattern, settings] = query_best(storage, details.url);
+    const allow = !!(settings && settings.allow);
+    const nonce = gen_nonce();
+    const policy = {allow, url, nonce};
+
+    let headers = details.responseHeaders;
+    let skip = false;
+    for (const header of headers) {
+	if ((header.name.toLowerCase().trim() === "content-disposition" &&
+	     /^\s*attachment\s*(;.*)$/i.test(header.value)))
+	    skip = true;
+    }
+
+    headers = inject_csp_headers(details, headers, policy);
+
+    skip = skip || (details.statusCode >= 300 && details.statusCode < 400);
+    if (!skip) {
+	/* Check for API availability. */
+	if (browser.webRequest.filterResponseData)
+	    headers = apply_stream_filter(details, headers, policy);
+    }
+
+    return {responseHeaders: headers};
+}
+
+async function start_webRequest_operations()
+{
+    storage = await get_storage();
+
+    const extra_opts = ["blocking", "responseHeaders"];
+    if (is_chrome)
+	extra_opts.push("extraHeaders");
+
+    browser.webRequest.onHeadersReceived.addListener(
+	on_headers_received,
+	{urls: ["<all_urls>"], types: ["main_frame", "sub_frame"]},
+	extra_opts
+    );
+}
+
+start_webRequest_operations();
diff --git a/background/policy_injector.js b/background/policy_injector.js
index 3398b53..1d4db6f 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -8,36 +8,21 @@
 
 /*
  * IMPORTS_START
- * IMPORT get_storage
- * IMPORT browser
- * IMPORT is_chrome
- * IMPORT gen_nonce
- * IMPORT is_privileged_url
  * IMPORT sign_data
  * IMPORT extract_signed
- * IMPORT query_best
  * IMPORT sanitize_csp_header
  * IMPORT csp_rule
  * IMPORT is_csp_header_name
  * IMPORTS_END
  */
 
-var storage;
-
-function headers_inject(details)
+function inject_csp_headers(details, headers, policy)
 {
     const url = details.url;
-    if (is_privileged_url(url))
-	return;
-
-    const [pattern, settings] = query_best(storage, url);
-    const allow = !!(settings && settings.allow);
-    const nonce = gen_nonce();
 
     let orig_csp_headers;
     let old_signature;
     let hachette_header;
-    let headers = details.responseHeaders;
 
     for (const header of headers.filter(h => h.name === "x-hachette")) {
 	const match = /^([^%])(%.*)$/.exec(header.value);
@@ -50,7 +35,7 @@ function headers_inject(details)
 
 	/* Confirmed- it's the originals, smuggled in! */
 	orig_csp_headers = old_data.csp_headers;
-	old_signature = old_data.policy_signature;
+	old_signature = old_data.policy_sig;
 
 	hachette_header = header;
 	break;
@@ -65,21 +50,20 @@ function headers_inject(details)
 	headers.filter(h => is_csp_header_name(h.name));
 
     /* When blocking remove report-only CSP headers that snitch on us. */
-    headers = headers.filter(h => !is_csp_header_name(h.name, !allow));
+    headers = headers.filter(h => !is_csp_header_name(h.name, !policy.allow));
 
     if (old_signature)
 	headers = headers.filter(h => h.name.search(old_signature) === -1);
 
-    const policy_object = {allow, nonce, url};
-    const sanitizer = h => sanitize_csp_header(h, policy_object);
+    const sanitizer = h => sanitize_csp_header(h, policy);
     headers.push(...orig_csp_headers.map(sanitizer));
 
-    const policy = encodeURIComponent(JSON.stringify(policy_object));
-    const policy_signature = sign_data(policy, new Date());
+    const policy_str = encodeURIComponent(JSON.stringify(policy));
+    const policy_sig = sign_data(policy_str, new Date());
     const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
     headers.push({
 	name: "Set-Cookie",
-	value: `hachette-${policy_signature}=${policy}; Expires=${later_30sec};`
+	value: `hachette-${policy_sig}=${policy_str}; Expires=${later_30sec};`
     });
 
     /*
@@ -87,37 +71,22 @@ function headers_inject(details)
      * These are signed with a time of 0, as it's not clear there is a limit on
      * how long Firefox might retain headers in the cache.
      */
-    let hachette_data = {csp_headers: orig_csp_headers, policy_signature, url};
+    let hachette_data = {csp_headers: orig_csp_headers, policy_sig, url};
     hachette_data = encodeURIComponent(JSON.stringify(hachette_data));
     hachette_header.value = sign_data(hachette_data, 0) + hachette_data;
 
     /* To ensure there is a CSP header if required */
-    if (!allow)
-	headers.push({name: "content-security-policy", value: csp_rule(nonce)});
+    if (!policy.allow)
+	headers.push({
+	    name: "content-security-policy",
+	    value: csp_rule(policy.nonce)
+	});
 
-    return {responseHeaders: headers};
-}
-
-async function start_policy_injector()
-{
-    storage = await get_storage();
-
-    let extra_opts = ["blocking", "responseHeaders"];
-    if (is_chrome)
-	extra_opts.push("extraHeaders");
-
-    browser.webRequest.onHeadersReceived.addListener(
-	headers_inject,
-	{
-	    urls: ["<all_urls>"],
-	    types: ["main_frame", "sub_frame"]
-	},
-	extra_opts
-    );
+    return headers;
 }
 
 /*
  * EXPORTS_START
- * EXPORT start_policy_injector
+ * EXPORT inject_csp_headers
  * EXPORTS_END
  */
diff --git a/background/stream_filter.js b/background/stream_filter.js
new file mode 100644
index 0000000..2dce811
--- /dev/null
+++ b/background/stream_filter.js
@@ -0,0 +1,176 @@
+/**
+ * Hachette modifying a web page using the StreamFilter API
+ *
+ * Copyright (C) 2018 Giorgio Maone <giorgio@maone.net>
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ *
+ * Derived from `bg/ResponseProcessor.js' and `bg/ResponseMetaData.js'
+ * in LibreJS.
+ */
+
+/*
+ * IMPORTS_START
+ * IMPORT browser
+ * IMPORTS_END
+ */
+
+function validate_encoding(charset)
+{
+    try {
+	new TextDecoder();
+	return charset;
+    } catch(e) {
+	return undefined;
+    }
+}
+
+function is_content_type_header(header)
+{
+    header.name.toLowerCase().trim() === "content-type";
+}
+
+const charset_reg = /;\s*charset\s*=\s*([\w-]+)/i;
+
+function properties_from_headers(headers)
+{
+    const properties = {};
+
+    for (const header of headers.filter(is_content_type_header)) {
+	const match = charset_reg.exec(header.value);
+	if (!properties.detected_charset && validate_encoding(match[1]))
+	    properties.detected_charset = match[1];
+
+	if (/html/i.test(header.value))
+	    properties.html = true;
+    }
+
+    return properties;
+}
+
+const UTF8_BOM = [0xef, 0xbb, 0xbf];
+const BOMs = [
+    [UTF8_BOM, "utf-8"],
+    [[0xfe, 0xff], "utf-16be"],
+    [[0xff, 0xfe], "utf-16le"]
+];
+
+function charset_from_BOM(data)
+{
+    for (const [BOM, charset] of BOMs) {
+	if (BOM.reduce((ac, byte, i) => ac && byte === data[i], true))
+	    return charset;
+    }
+
+    return "";
+}
+
+const charset_attrs =
+      ['charset', 'http-equiv="content-type"', 'content*="charset"'];
+const charset_meta_selector =
+      charset_attrs.map(a => `head>meta[${a}]`).join(", ");
+
+function charset_from_meta_tags(doc)
+{
+    for (const meta of doc.querySelectorAll(charset_meta_selector)) {
+	const maybe_charset = meta.getAttribute("charset");
+	if (maybe_charset && validate_encoding(maybe_charset))
+	    return maybe_charset;
+
+        const match = charset_reg.exec(meta.getAttribute("content"));
+        if (match && validate_encoding(match[1]))
+	    return match[1];
+    }
+
+    return undefined;
+}
+
+function create_decoder(properties, data)
+{
+    let charset = charset_from_BOM(data) || properties.detected_charset;
+    if (!charset && data.indexOf(0) !== -1) {
+        console.debug("Warning: zeroes in bytestream, probable cached encoding mismatch. Trying to decode it as UTF-16.",
+		      properties);
+	return new TextDecoder("utf-16be");
+    }
+
+    /* Missing HTTP charset, sniffing in content... */
+    /*
+     * TODO: I recall there is some standard saying how early in the doc the
+     * charset has to be specified. We could process just this part of data.
+     */
+    const text = new TextDecoder("latin1").decode(data, {stream: true});
+    properties.html = properties.html || /html/i.test(text);
+
+    if (properties.html) {
+	const tmp_doc = new DOMParser().parseFromString(text, "text/html");
+	charset = charset_from_meta_tags(tmp_doc);
+    }
+
+    return new TextDecoder(charset || "latin1");
+}
+
+function filter_data(properties, event)
+{
+    const data = new Uint8Array(event.data);
+    let first_chunk = false;
+    if (!properties.decoder) {
+	first_chunk = true;
+	properties.decoder = create_decoder(properties, data);
+	properties.encoder = new TextEncoder();
+	/* Force UTF-8, this is the only encoding we can produce. */
+	properties.filter.write(new Uint8Array(UTF8_BOM));
+    }
+
+    let decoded = properties.decoder.decode(data);
+
+    if (first_chunk) {
+	/*
+	 * HAX! Our content scripts that execute at `document_start' will always
+	 * run before the first script in the document, but under Mozilla some
+	 * `<meta>' tags might already be loaded at that point. Here we inject a
+	 * dummy `<script>' at the beginning (before any `<meta>' tags) that
+	 * will force `document_start' to happen earlier. This way our content
+	 * scripts will be able to sanitize `http-equiv' tags with CSP rules
+	 * that would otherwise stop our injected scripts from executing.
+	 */
+	const dummy_script =
+	      `<script data-hachette-deleteme="${properties.policy.nonce}" nonce="${properties.policy.nonce}">null</script>`;
+	const doctype_decl = /^(\s*<!doctype[^<>"']*>)?/i.exec(decoded)[0];
+	decoded = doctype_decl + dummy_script +
+	    decoded.substring(doctype_decl.length);
+    }
+
+    properties.filter.write(properties.encoder.encode(decoded));
+
+    if (properties.decoder.encoding === "utf-8")
+	properties.filter.disconnect();
+}
+
+function apply_stream_filter(details, headers, policy)
+{
+    if (policy.allow)
+	return headers;
+
+    const properties = properties_from_headers(headers);
+    properties.policy = policy;
+
+    properties.filter =
+	browser.webRequest.filterResponseData(details.requestId);
+
+    properties.filter.ondata = event => filter_data(properties, event);
+    properties.filter.onstop = () => properties.filter.close();
+
+    /*
+     * In the future we might consider modifying the headers that specify
+     * encoding. For now we are not yet doing it, though. However, we
+     * prepend the data with UTF-8 BOM which should be enough.
+     */
+    return headers;
+}
+
+/*
+ * EXPORTS_START
+ * EXPORT apply_stream_filter
+ * EXPORTS_END
+ */
diff --git a/content/main.js b/content/main.js
index 441636c..4ae7738 100644
--- a/content/main.js
+++ b/content/main.js
@@ -47,10 +47,7 @@ if (!is_privileged_url(document.URL)) {
 
     handle_page_actions(policy.nonce);
 
-    if (!policy.allow && is_mozilla)
-	addEventListener('beforescriptexecute', mozilla_suppress_scripts, true);
-
-    if (!policy.allow && is_chrome) {
+    if (!policy.allow) {
 	const old_html = document.documentElement;
 	const new_html = document.createElement("html");
 	old_html.replaceWith(new_html);
diff --git a/content/sanitize_document.js b/content/sanitize_document.js
index 1533526..727bb6c 100644
--- a/content/sanitize_document.js
+++ b/content/sanitize_document.js
@@ -43,76 +43,100 @@ function block_attribute(node, attr)
     node.removeAttribute(attr);
 }
 
-function sanitize_script(script, policy)
+function sanitize_script(script, data)
 {
-    if (policy.allow)
+    if (script.getAttribute("data-hachette-deleteme") === data.policy.nonce) {
+	script.remove();
+	script.hachette_deleted = true;
+	script.hachette_ignore = true;
+    }
+
+    if (data.policy.allow)
 	return;
 
     block_attribute(script, "type");
     script.setAttribute("type", "application/json");
 }
 
-function inject_csp(head, policy)
+function inject_csp(head, data)
 {
-    if (policy.allow)
+    if (data.policy.allow)
 	return;
 
     const meta = document.createElement("meta");
     meta.setAttribute("http-equiv", "Content-Security-Policy");
-    meta.setAttribute("content", csp_rule(policy.nonce));
+    meta.setAttribute("content", csp_rule(data.policy.nonce));
     meta.hachette_ignore = true;
     head.prepend(meta);
+
+    data.new_added.unshift([meta, head]);
 }
 
-function sanitize_http_equiv_csp_rule(meta, policy)
+function sanitize_http_equiv_csp_rule(meta, data)
 {
     const http_equiv = meta.getAttribute("http-equiv");
+    const value = meta.content;
 
-    if (!is_csp_header_name(http_equiv, !policy.allow))
+    if (!value || !is_csp_header_name(http_equiv, !data.policy.allow))
 	return;
 
-    if (policy.allow || is_csp_header_name(http_equiv, false)) {
-	let value = meta.getAttribute("content");
-	block_attribute(meta, "content");
-	if (value) {
-	    value = sanitize_csp_header({value}, policy).value;
-	    meta.setAttribute("content", value);
-	}
-	return;
-    }
+    block_attribute(meta, "content");
 
-    block_attribute(meta, "http-equiv");
+    if (data.policy.allow || is_csp_header_name(http_equiv, false))
+	meta.content = sanitize_csp_header({value}, data.policy).value;
 }
 
-function sanitize_node(node, policy)
+function sanitize_node(node, data)
 {
     if (node.tagName === "SCRIPT")
-	sanitize_script(node, policy);
+	sanitize_script(node, data);
 
     if (node.tagName === "HEAD")
-	inject_csp(node, policy);
+	inject_csp(node, data);
 
     if (node.tagName === "META")
-	sanitize_http_equiv_csp_rule(node, policy);
+	sanitize_http_equiv_csp_rule(node, data);
+
+    if (!data.policy.allow)
+	sanitize_attributes(node, data);
+}
 
-    if (!policy.allow)
-	sanitize_attributes(node, policy);
+/*
+ * Instead of calling writer directly with multiple small chunks of reconstruced
+ * HTML code, we utilize `setTimeout()' to only have it called once,
+ * asynchronously.
+ */
+function do_write_callback(data)
+{
+    data.writer(data.chunks.join(""));
+    data.chunks = [];
+
+    if (data.finished && data.finisher)
+	data.finisher();
+}
+
+function do_write(chunk, data)
+{
+    data.chunks.push(chunk);
+    clearTimeout(data.write_timeout);
+    data.write_timeout = setTimeout(() => do_write_callback(data), 0);
 }
 
 const serializer = new XMLSerializer();
 
-function start_node(node, data)
+function start_serializing_node(node, data)
 {
+    node.hachette_started = true;
+
     if (!data.writer)
 	return;
 
-    node.hachette_started = true;
     const clone = node.cloneNode(false);
     clone.textContent = data.uniq;
-    data.writer(data.uniq_reg.exec(clone.outerHTML)[1]);
+    do_write(data.uniq_reg.exec(clone.outerHTML)[1], data);
 }
 
-function finish_node(node, data)
+function finish_serializing_node(node, data)
 {
     const nodes_to_process = [node];
 
@@ -127,40 +151,103 @@ function finish_node(node, data)
     while (nodes_to_process.length > 0) {
 	const node = nodes_to_process.pop();
 	node.remove();
+	node.hachette_ignore = true;
 
 	if (!data.writer)
 	    continue;
 
 	if (node.hachette_started) {
 	    node.textContent = data.uniq;
-	    data.writer(data.uniq_reg.exec(node.outerHTML)[2]);
+	    do_write(data.uniq_reg.exec(node.outerHTML)[2], data);
+	    continue;
+	}
+
+	do_write(node.outerHTML || serializer.serializeToString(node), data);
+    }
+}
+
+function process_initial_nodes(node, data)
+{
+    if (data.processed_initial_nodes)
+	return;
+
+    data.processed_initial_nodes = true;
+
+    start_serializing_node(data.html_root, data);
+
+    const new_added = [];
+    const nodes_to_process = [data.html_root];
+
+    let i = 0;
+    while (nodes_to_process.length > 0) {
+	let current = nodes_to_process.shift();
+
+	if (current.firstChild) {
+	    if (current.firstChild === node)
+		break;
+	    nodes_to_process.unshift(current.firstChild, current);
+	    new_added.push([current.firstChild, current]);
 	    continue;
 	}
 
-	data.writer(node.outerHTML || serializer.serializeToString(node));
+	while (current && !current.nextSibling)
+	    current = nodes_to_process.shift();
+
+	if (!current || current.nextSibling === node)
+	    break;
+
+	nodes_to_process.unshift(current.nextSibling);
+	new_added.push([current.nextSibling, nodes_to_process[1]]);
     }
+
+    data.new_added.unshift(...new_added);
 }
 
 /*
  * Important! Due to some weirdness node.parentElement is not alway correct
- * under Chromium. Track node relations manually.
+ * in MutationRecords under Chromium. Track node relations manually.
  */
 function handle_added_node(node, true_parent, data)
 {
-    if (node.hachette_ignore || true_parent.hachette_ignore)
-	return;
+    /*
+     * Functions we call here might cause new nodes to be injected or found
+     * that require processing before the one we got in function argument.
+     * We rely on those functions putting the node(s) they create/find at the
+     * very beginning of the `new_added' queue and (for created nodes) setting
+     * their `hachette_ignore' property, based on which their MutationRecord
+     * will not be processed. A function can also mark a node already in the
+     * `new_added' queue as not eligible for processing by setting its
+     * `hachette_deleted' property.
+     */
 
-    if (!true_parent.hachette_started)
-	start_node(true_parent, data)
+    process_initial_nodes(node, data);
 
-    sanitize_node(node, data.policy);
+    data.new_added.push([node, true_parent]);
 
-    if (data.node_eater)
-	data.node_eater(node, true_parent);
+    while (data.new_added.length > 0) {
+	[node, true_parent] = data.new_added.shift();
 
-    finish_node(true_parent.hachette_last_added, data);
+	if (true_parent.hachette_deleted)
+	    node.hachette_deleted = true;
+	if (node.hachette_deleted)
+	    continue;
+
+	if (!true_parent.hachette_started)
+	    start_serializing_node(true_parent, data)
+
+	if (!node.hachette_ignore)
+	    sanitize_node(node, data);
+
+	if (node.hachette_deleted)
+	    continue;
+
+	if (data.node_eater)
+	    data.node_eater(node, true_parent);
 
-    true_parent.hachette_last_added = node;
+	finish_serializing_node(true_parent.hachette_last_added, data);
+
+	true_parent.hachette_last_added = node;
+    }
 }
 
 function handle_mutation(mutations, data)
@@ -170,28 +257,76 @@ function handle_mutation(mutations, data)
      * node.parentElement. The former is the correct one.
      */
     for (const mutation of mutations) {
-	for (const node of mutation.addedNodes)
+	for (const node of mutation.addedNodes) {
+	    /* Check for nodes added by ourselves. */
+	    if (mutation.target.hachette_ignore)
+		node.hachette_ignore = true;
+	    if (node.hachette_ignore)
+		continue;
+
 	    handle_added_node(node, mutation.target, data);
+	}
     }
 }
 
 function finish_processing(data)
 {
+    process_initial_nodes(undefined, data);
+
+    /*
+     * The `finisher' callback should be called, if provided. Normally our
+     * function that performs the last write does it after seeing `finished'
+     * set to `true'. If, however, there's no `writer' callback and hence no
+     * writes to perform, we need to take care of calling `finisher' here.
+     */
+    data.finished = true;
     handle_mutation(data.observer.takeRecords(), data);
-    finish_node(data.html_element, data);
     data.observer.disconnect();
+
+    /*
+     * Additional whitespace that was after `</body>' gets appended to body.
+     * Although it's a minor issue, it is not what we want. There's no way to
+     * tell exactly what part of that whitespace was after `</body>' and what
+     * was before, so we just replace it with a single newline which looks good
+     * when printed.
+     */
+    const body = data.html_root.lastChild;
+    const text = body && body.tagName === "BODY" && body.lastChild;
+    if (text && text.nodeName === "#text") {
+	const new_content = /^([\S\s]*\S)?\s*$/.exec(text.textContent)[1] || "";
+	text.textContent = new_content + "\n";
+    }
+
+    finish_serializing_node(data.html_root, data);
+    if (!data.writer && data.finisher)
+	setTimeout(data.finisher, 0);
 }
 
-function modify_on_the_fly(html_element, policy, consumers)
+/*
+ * This function sanitizes `html_root' according to `policy'. It is capable of
+ * working on an HTML document that is being written to, sanitizing new nodes
+ * as they appear.
+ *
+ * `consumers' object may contain 3 optional callback functions: `writer',
+ * `node_eater' and `finisher'. The first one, if present, is called with chunks
+ * of reconstructed HTML code. The second one, if present, gets called for every
+ * added node with 2 arguments: that node and its parent. The third one is
+ * called at the end, after all processing has been done.
+ *
+ * `modify_on_the_fly()' returns a callback that should be called (with no
+ * arguments) once the document of html_root has finished being written to.
+ * Unfortunately, due to specifics behavior of document that has had its
+ * documentElement replaced
+ */
+function modify_on_the_fly(html_root, policy, consumers)
 {
     const uniq = gen_nonce();
-    const uniq_reg = new RegExp(`^(.*)${uniq}(.*)$`);
-    const data = {policy, html_element, uniq, uniq_reg, ...consumers};
-
-    start_node(data.html_element, data);
+    const uniq_reg = new RegExp(`^([\\s\\S]*)${uniq}([\\s\\S]*)$`);
+    const data = {policy, html_root, uniq, uniq_reg, chunks: [], new_added: []};
+    Object.assign(data, consumers);
 
     var observer = new MutationObserver(m => handle_mutation(m, data));
-    observer.observe(data.html_element, {
+    observer.observe(data.html_root, {
      	attributes: true,
 	childList: true,
 	subtree: true
diff --git a/copyright b/copyright
index 05a16aa..40126fe 100644
--- a/copyright
+++ b/copyright
@@ -20,6 +20,13 @@ Copyright: 2021 Wojtek Kosior <koszko@koszko.org>
    2021 jahoti <jahoti@tilde.team>
 License: GPL-3+-javascript or Alicense-1.0
 
+Files: background/stream_filter.js
+Copyright: 2018 Giorgio Maone <giorgio@maone.net>
+   2021 Wojtek Kosior <koszko@koszko.org>
+License: GPL-3+-javascript or Alicense-1.0, and GPL-3+
+Comment: Code by Wojtek is dual-licensed under GPL-3+-javascript and
+ Alicense-1.0. Giorgio's code is under GPL-3+.
+
 Files: *.html README.txt copyright
 Copyright: 2021 Wojtek Kosior <koszko@koszko.org>
 License: GPL-3+ or Alicense-1.0 or CC-BY-SA-4.0
-- 
cgit v1.2.3


From 2875397fb887a5b09b5f39d6b3a75419a516dd07 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Thu, 26 Aug 2021 11:50:36 +0200
Subject: improve signing\n\nSignature timestamp is now handled in a saner way.
 Sha256 implementation is no longer pulled in contexts that don't require it.

---
 background/main.js            |  2 +-
 background/policy_injector.js | 33 +++++++++----------
 common/misc.js                | 38 +---------------------
 common/signing.js             | 73 +++++++++++++++++++++++++++++++++++++++++++
 content/main.js               | 33 ++++++++++++++-----
 5 files changed, 118 insertions(+), 61 deletions(-)
 create mode 100644 common/signing.js

(limited to 'content/main.js')

diff --git a/background/main.js b/background/main.js
index 85f8ce8..2c8a87b 100644
--- a/background/main.js
+++ b/background/main.js
@@ -69,7 +69,7 @@ function on_headers_received(details)
 	    skip = true;
     }
 
-    headers = inject_csp_headers(details, headers, policy);
+    headers = inject_csp_headers(headers, policy);
 
     skip = skip || (details.statusCode >= 300 && details.statusCode < 400);
     if (!skip) {
diff --git a/background/policy_injector.js b/background/policy_injector.js
index 1d4db6f..72318d4 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -16,25 +16,27 @@
  * IMPORTS_END
  */
 
-function inject_csp_headers(details, headers, policy)
+function inject_csp_headers(headers, policy)
 {
-    const url = details.url;
-
-    let orig_csp_headers;
+    let csp_headers;
     let old_signature;
     let hachette_header;
 
     for (const header of headers.filter(h => h.name === "x-hachette")) {
-	const match = /^([^%])(%.*)$/.exec(header.value);
+	/* x-hachette header has format: <signature>_0_<data> */
+	const match = /^([^_]+)_(0_.*)$/.exec(header.value);
 	if (!match)
 	    continue;
 
-	const old_data = extract_signed(...match.splice(1, 2), [[0]]);
-	if (!old_data || old_data.url !== url)
+	const result = extract_signed(...match.slice(1, 3));
+	if (result.fail)
 	    continue;
 
+	/* This should succeed - it's our self-produced valid JSON. */
+	const old_data = JSON.parse(decodeURIComponent(result.data));
+
 	/* Confirmed- it's the originals, smuggled in! */
-	orig_csp_headers = old_data.csp_headers;
+	csp_headers = old_data.csp_headers;
 	old_signature = old_data.policy_sig;
 
 	hachette_header = header;
@@ -46,24 +48,23 @@ function inject_csp_headers(details, headers, policy)
 	headers.push(hachette_header);
     }
 
-    orig_csp_headers = orig_csp_headers ||
+    csp_headers = csp_headers ||
 	headers.filter(h => is_csp_header_name(h.name));
 
     /* When blocking remove report-only CSP headers that snitch on us. */
     headers = headers.filter(h => !is_csp_header_name(h.name, !policy.allow));
 
     if (old_signature)
-	headers = headers.filter(h => h.name.search(old_signature) === -1);
+	headers = headers.filter(h => h.value.search(old_signature) === -1);
 
-    const sanitizer = h => sanitize_csp_header(h, policy);
-    headers.push(...orig_csp_headers.map(sanitizer));
+    headers.push(...csp_headers.map(h => sanitize_csp_header(h, policy)));
 
     const policy_str = encodeURIComponent(JSON.stringify(policy));
-    const policy_sig = sign_data(policy_str, new Date());
+    const signed_policy = sign_data(policy_str, new Date().getTime());
     const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
     headers.push({
 	name: "Set-Cookie",
-	value: `hachette-${policy_sig}=${policy_str}; Expires=${later_30sec};`
+	value: `hachette-${signed_policy.join("=")}; Expires=${later_30sec};`
     });
 
     /*
@@ -71,9 +72,9 @@ function inject_csp_headers(details, headers, policy)
      * These are signed with a time of 0, as it's not clear there is a limit on
      * how long Firefox might retain headers in the cache.
      */
-    let hachette_data = {csp_headers: orig_csp_headers, policy_sig, url};
+    let hachette_data = {csp_headers, policy_sig: signed_policy[0]};
     hachette_data = encodeURIComponent(JSON.stringify(hachette_data));
-    hachette_header.value = sign_data(hachette_data, 0) + hachette_data;
+    hachette_header.value = sign_data(hachette_data, 0).join("_");
 
     /* To ensure there is a CSP header if required */
     if (!policy.allow)
diff --git a/common/misc.js b/common/misc.js
index 8894d60..d6b9662 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -8,9 +8,7 @@
 
 /*
  * IMPORTS_START
- * IMPORT sha256
  * IMPORT browser
- * IMPORT is_chrome
  * IMPORT TYPE_NAME
  * IMPORT TYPE_PREFIX
  * IMPORTS_END
@@ -45,32 +43,6 @@ function gen_nonce(length) // Default 16
     return Uint8toHex(randomData);
 }
 
-function get_secure_salt()
-{
-    if (is_chrome)
-	return browser.runtime.getManifest().key.substring(0, 50);
-    else
-	return browser.runtime.getURL("dummy");
-}
-
-function extract_signed(signature, data, times)
-{
-    const now = new Date();
-    times = times || [[now], [now, -1]];
-
-    const reductor =
-	  (ok, time) => ok || signature === sign_data(data, ...time);
-    if (!times.reduce(reductor, false))
-	return undefined;
-
-    try {
-	return JSON.parse(decodeURIComponent(data));
-    } catch (e) {
-	/* This should not be reached - it's our self-produced valid JSON. */
-	console.log("Unexpected internal error - invalid JSON smuggled!", e);
-    }
-}
-
 /* csp rule that blocks all scripts except for those injected by us */
 function csp_rule(nonce)
 {
@@ -89,7 +61,7 @@ const report_only_header_name = "content-security-policy-report-only";
 
 function is_csp_header_name(string, include_report_only)
 {
-    string = string && string.toLowerCase() || "";
+    string = string && string.toLowerCase().trim() || "";
 
     return (include_report_only && string === report_only_header_name) ||
 	csp_header_names.has(string);
@@ -118,12 +90,6 @@ function is_privileged_url(url)
     return !!/^(chrome(-extension)?|moz-extension):\/\/|^about:/i.exec(url);
 }
 
-/* Sign a given string for a given time */
-function sign_data(data, now, hours_offset) {
-    let time = Math.floor(now / 3600000) + (hours_offset || 0);
-    return sha256(get_secure_salt() + time + data);
-}
-
 /* Parse a CSP header */
 function parse_csp(csp) {
     let directive, directive_array;
@@ -193,8 +159,6 @@ const matchers = {
 /*
  * EXPORTS_START
  * EXPORT gen_nonce
- * EXPORT extract_signed
- * EXPORT sign_data
  * EXPORT csp_rule
  * EXPORT is_csp_header_name
  * EXPORT nice_name
diff --git a/common/signing.js b/common/signing.js
new file mode 100644
index 0000000..2171714
--- /dev/null
+++ b/common/signing.js
@@ -0,0 +1,73 @@
+/**
+ * part of Hachette
+ * Functions related to "signing" of data, refactored to a separate file.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * IMPORTS_START
+ * IMPORT sha256
+ * IMPORT browser
+ * IMPORT is_chrome
+ * IMPORTS_END
+ */
+
+/*
+ * In order to make certain data synchronously accessible in certain contexts,
+ * hachette smuggles it in string form in places like cookies, URLs and headers.
+ * When using the smuggled data, we first need to make sure it isn't spoofed.
+ * For that, we use this pseudo-signing mechanism.
+ *
+ * Despite what name suggests, no assymetric cryptography is involved, as it
+ * would bring no additional benefits and would incur bigger performance
+ * overhead. Instead, we hash the string data together with some secret value
+ * that is supposed to be known only by this browser instance. Resulting hash
+ * sum plays the role of the signature. In the hash we also include current
+ * time. This way, even if signed data leaks (which shouldn't happen in the
+ * first place), an attacker won't be able to re-use it indefinitely.
+ *
+ * The secret shared between execution contexts has to be available
+ * synchronously. Under Mozilla, this is the extension's per-session id. Under
+ * Chromium, this is the key that resides in the manifest.
+ *
+ * An idea to (under Chromium) instead store the secret in a file fetched
+ * synchronously using XMLHttpRequest is being considered.
+ */
+
+function get_secret()
+{
+    if (is_chrome)
+	return browser.runtime.getManifest().key.substring(0, 50);
+    else
+	return browser.runtime.getURL("dummy");
+}
+
+function extract_signed(signature, signed_data)
+{
+    const match = /^([1-9][0-9]{12}|0)_(.*)$/.exec(signed_data);
+    if (!match)
+	return {fail: "bad format"};
+
+    const result = {time: parseInt(match[1]), data: match[2]};
+    if (sign_data(result.data, result.time)[0] !== signature)
+	result.fail = "bad signature";
+
+    return result;
+}
+
+/*
+ * Sign a given string for a given time. Time should be either 0 or in the range
+ * 10^12 <= time < 10^13.
+ */
+function sign_data(data, time) {
+    return [sha256(get_secret() + time + data), `${time}_${data}`];
+}
+
+/*
+ * EXPORTS_START
+ * EXPORT extract_signed
+ * EXPORT sign_data
+ * EXPORTS_END
+ */
diff --git a/content/main.js b/content/main.js
index 4ae7738..984b3cb 100644
--- a/content/main.js
+++ b/content/main.js
@@ -32,17 +32,36 @@ function accept_node(node, parent)
 }
 
 if (!is_privileged_url(document.URL)) {
-    const reductor =
-	  (ac, [_, sig, pol]) => ac[0] && ac || [extract_signed(sig, pol), sig];
-    const matches = [...document.cookie.matchAll(/hachette-(\w*)=([^;]*)/g)];
-    let [policy, signature] = matches.reduce(reductor, []);
+    /* Signature valid for half an hour. */
+    const min_time = new Date().getTime() - 1800 * 1000;
+    let best_result = {time: -1};
+    let policy = null;
+    const extracted_signatures = [];
+    for (const match of document.cookie.matchAll(/hachette-(\w*)=([^;]*)/g)) {
+	const new_result = extract_signed(...match.slice(1, 3));
+	if (new_result.fail)
+	    continue;
 
-    if (!policy || policy.url !== document.URL) {
-	console.log("WARNING! Using default policy!!!");
+	extracted_signatures.push(match[1]);
+
+	if (new_result.time < Math.max(min_time, best_result.time))
+	    continue;
+
+	/* This should succeed - it's our self-produced valid JSON. */
+	const new_policy = JSON.parse(decodeURIComponent(new_result.data));
+	if (new_policy.url !== document.URL)
+	    continue;
+
+	best_result = new_result;
+	policy = new_policy;
+    }
+
+    if (!policy) {
+	console.warn("WARNING! Using default policy!!!");
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
-    if (signature)
+    for (const signature of extracted_signatures)
 	document.cookie = `hachette-${signature}=; Max-Age=-1;`;
 
     handle_page_actions(policy.nonce);
-- 
cgit v1.2.3


From 538376341e9a50ebd350897fe26f43c433f0ee06 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Fri, 27 Aug 2021 10:01:32 +0200
Subject: enable whitelisting of `file://' protocol\n\nThis commit additionally
 also changes the semantics of triple asterisk wildcard in URL path.

---
 common/misc.js           |  12 ++--
 common/patterns.js       | 160 ++++++++++++++++++++++-------------------------
 common/settings_query.js |  27 ++++----
 content/freezer.js       |   1 +
 content/main.js          |  86 ++++++++++++++++++++++---
 content/page_actions.js  |  22 ++++---
 html/display-panel.js    |   5 +-
 7 files changed, 190 insertions(+), 123 deletions(-)

(limited to 'content/main.js')

diff --git a/common/misc.js b/common/misc.js
index d6b9662..fd70f62 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -84,11 +84,13 @@ function open_in_settings(prefix, name)
     window.open(url, "_blank");
 }
 
-/* Check if url corresponds to a browser's special page */
-function is_privileged_url(url)
-{
-    return !!/^(chrome(-extension)?|moz-extension):\/\/|^about:/i.exec(url);
-}
+/*
+ * Check if url corresponds to a browser's special page (or a directory index in
+ * case of `file://' protocol).
+ */
+const privileged_reg =
+      /^(chrome(-extension)?|moz-extension):\/\/|^about:|^file:\/\/.*\/$/;
+const is_privileged_url = url => privileged_reg.test(url);
 
 /* Parse a CSP header */
 function parse_csp(csp) {
diff --git a/common/patterns.js b/common/patterns.js
index be7c650..0a322b0 100644
--- a/common/patterns.js
+++ b/common/patterns.js
@@ -5,35 +5,41 @@
  * Redistribution terms are gathered in the `copyright' file.
  */
 
-const proto_re = "[a-zA-Z]*:\/\/";
+const proto_regex = /^(\w+):\/\/(.*)$/;
+
 const domain_re = "[^/?#]+";
-const segments_re = "/[^?#]*";
-const query_re = "\\?[^#]*";
-
-const url_regex = new RegExp(`\
-^\
-(${proto_re})\
-(${domain_re})\
-(${segments_re})?\
-(${query_re})?\
-#?.*\$\
-`);
+const path_re = "[^?#]*";
+const query_re = "\\??[^#]*";
+
+const http_regex = new RegExp(`^(${domain_re})(${path_re})(${query_re}).*`);
+
+const file_regex = new RegExp(`^(${path_re}).*`);
 
 function deconstruct_url(url)
 {
-    const regex_match = url_regex.exec(url);
-    if (regex_match === null)
+    const proto_match = proto_regex.exec(url);
+    if (proto_match === null)
 	return undefined;
 
-    let [_, proto, domain, path, query] = regex_match;
+    const deco = {proto: proto_match[1]};
 
-    domain = domain.split(".");
-    let path_trailing_dash =
-	path && path[path.length - 1] === "/";
-    path = (path || "").split("/").filter(s => s !== "");
-    path.unshift("");
+    if (deco.proto === "file") {
+	deco.path = file_regex.exec(proto_match[2])[1];
+    } else {
+	const http_match = http_regex.exec(proto_match[2]);
+	if (!http_match)
+	    return undefined;
+	[deco.domain, deco.path, deco.query] = http_match.slice(1, 4);
+	deco.domain = deco.domain.split(".");
+    }
 
-    return {proto, domain, path, query, path_trailing_dash};
+    const leading_dash = deco.path[0] === "/";
+    deco.trailing_dash = deco.path[deco.path.length - 1] === "/";
+    deco.path = deco.path.split("/").filter(s => s !== "");
+    if (leading_dash || deco.path.length === 0)
+	deco.path.unshift("");
+
+    return deco;
 }
 
 /* Be sane: both arguments should be arrays of length >= 2 */
@@ -104,84 +110,70 @@ function url_matches(url, pattern)
 	return false
     }
 
-    if (pattern_deco.proto !== url_deco.proto)
-	return false;
-
-    return domain_matches(url_deco.domain, pattern_deco.domain) &&
-	path_matches(url_deco.path, url_deco.path_trailing_dash,
-		     pattern_deco.path, pattern_deco.path_trailing_dash);
+    return pattern_deco.proto === url_deco.proto &&
+	!(pattern_deco.proto === "file" && pattern_deco.trailing_dash) &&
+	!!url_deco.domain === !!pattern_deco.domain &&
+	(!url_deco.domain ||
+	 domain_matches(url_deco.domain, pattern_deco.domain)) &&
+	path_matches(url_deco.path, url_deco.trailing_dash,
+		     pattern_deco.path, pattern_deco.trailing_dash);
 }
 
-/*
- * Call callback for every possible pattern that matches url. Return when there
- * are no more patterns or callback returns false.
- */
-function for_each_possible_pattern(url, callback)
+function* each_domain_pattern(domain_segments)
 {
-    const deco = deconstruct_url(url);
-
-    if (deco === undefined) {
-	console.log("bad url format", url);
-	return;
+    for (let slice = 0; slice < domain_segments.length; slice++) {
+	const domain_part = domain_segments.slice(slice).join(".");
+	const domain_wildcards = [];
+	if (slice === 0)
+	    yield domain_part;
+	if (slice === 1)
+	    yield "*." + domain_part;
+	if (slice > 1)
+	    yield "**." + domain_part;
+	yield "***." + domain_part;
     }
+}
 
-    for (let d_slice = 0; d_slice < deco.domain.length; d_slice++) {
-	const domain_part = deco.domain.slice(d_slice).join(".");
-	const domain_wildcards = [];
-	if (d_slice === 0)
-	    domain_wildcards.push("");
-	if (d_slice === 1)
-	    domain_wildcards.push("*.");
-	if (d_slice > 0)
-	    domain_wildcards.push("**.");
-	domain_wildcards.push("***.");
-
-	for (const domain_wildcard of domain_wildcards) {
-	    const domain_pattern = domain_wildcard + domain_part;
-
-	    for (let s_slice = deco.path.length; s_slice > 0; s_slice--) {
-		const path_part = deco.path.slice(0, s_slice).join("/");
-		const path_wildcards = [];
-		if (s_slice === deco.path.length) {
-		    if (deco.path_trailing_dash)
-			path_wildcards.push("/");
-		    path_wildcards.push("");
-		}
-		if (s_slice === deco.path.length - 1 &&
-		    deco.path[s_slice] !== "*")
-		    path_wildcards.push("/*");
-		if (s_slice < deco.path.length &&
-		    (deco.path[s_slice] !== "**" ||
-		     s_slice < deco.path.length - 1))
-		    path_wildcards.push("/**");
-		if (deco.path[s_slice] !== "***" || s_slice < deco.path.length)
-		    path_wildcards.push("/***");
-
-		for (const path_wildcard of path_wildcards) {
-		    const path_pattern = path_part + path_wildcard;
-
-		    const pattern = deco.proto + domain_pattern + path_pattern;
-
-		    if (callback(pattern) === false)
-			return;
-		}
-	    }
+function* each_path_pattern(path_segments, trailing_dash)
+{
+    for (let slice = path_segments.length; slice > 0; slice--) {
+	const path_part = path_segments.slice(0, slice).join("/");
+	const path_wildcards = [];
+	if (slice === path_segments.length) {
+	    if (trailing_dash)
+		yield path_part + "/";
+	    yield path_part;
 	}
+	if (slice === path_segments.length - 1 && path_segments[slice] !== "*")
+	    yield path_part + "/*";
+	if (slice < path_segments.length - 1)
+	    yield path_part + "/**";
+	if (slice < path_segments.length - 1 ||
+	    path_segments[path_segments.length - 1] !== "***")
+	    yield path_part + "/***";
     }
 }
 
-function possible_patterns(url)
+/* Generate every possible pattern that matches url. */
+function* each_url_pattern(url)
 {
-    const patterns = [];
-    for_each_possible_pattern(url, patterns.push);
+    const deco = deconstruct_url(url);
 
-    return patterns;
+    if (deco === undefined) {
+	console.log("bad url format", url);
+	return false;
+    }
+
+    const all_domains = deco.domain ? each_domain_pattern(deco.domain) : [""];
+    for (const domain of all_domains) {
+	for (const path of each_path_pattern(deco.path, deco.trailing_dash))
+	    yield `${deco.proto}://${domain}${path}`;
+    }
 }
 
 /*
  * EXPORTS_START
  * EXPORT url_matches
- * EXPORT for_each_possible_pattern
- * EXPORT possible_patterns
+ * EXPORT each_url_pattern
  * EXPORTS_END
  */
diff --git a/common/settings_query.js b/common/settings_query.js
index e85ae63..b54e580 100644
--- a/common/settings_query.js
+++ b/common/settings_query.js
@@ -8,30 +8,25 @@
 /*
  * IMPORTS_START
  * IMPORT TYPE_PREFIX
- * IMPORT for_each_possible_pattern
+ * IMPORT each_url_pattern
  * IMPORTS_END
  */
 
-function check_pattern(storage, pattern, multiple, matched)
-{
-    const settings = storage.get(TYPE_PREFIX.PAGE, pattern);
-
-    if (settings === undefined)
-	return;
-
-    matched.push([pattern, settings]);
-
-    if (!multiple)
-	return false;
-}
-
 function query(storage, url, multiple)
 {
     const matched = [];
     const cb = p => check_pattern(storage, p, multiple, matched);
-    for_each_possible_pattern(url, cb);
+    for (const pattern of each_url_pattern(url)) {
+	const result = [pattern, storage.get(TYPE_PREFIX.PAGE, pattern)];
+	if (result[1] === undefined)
+	    continue;
+
+	if (!multiple)
+	    return result;
+	matched.push(result);
+    }
 
-    return multiple ? matched : (matched[0] || [undefined, undefined]);
+    return multiple ? matched : [undefined, undefined];
 }
 
 function query_best(storage, url)
diff --git a/content/freezer.js b/content/freezer.js
index 9dbc95e..0ea362e 100644
--- a/content/freezer.js
+++ b/content/freezer.js
@@ -49,6 +49,7 @@ function mozilla_suppress_scripts(e) {
 	console.log('Script suppressor has detached.');
 	return;
     }
+    console.log("script event", e);
     if (e.isTrusted && !e.target._hachette_payload) {
 	e.preventDefault();
 	console.log('Suppressed script', e.target);
diff --git a/content/main.js b/content/main.js
index 984b3cb..06d3bf1 100644
--- a/content/main.js
+++ b/content/main.js
@@ -10,6 +10,7 @@
  * IMPORTS_START
  * IMPORT handle_page_actions
  * IMPORT extract_signed
+ * IMPORT sign_data
  * IMPORT gen_nonce
  * IMPORT is_privileged_url
  * IMPORT mozilla_suppress_scripts
@@ -31,13 +32,13 @@ function accept_node(node, parent)
     parent.hachette_corresponding.appendChild(clone);
 }
 
-if (!is_privileged_url(document.URL)) {
-    /* Signature valid for half an hour. */
-    const min_time = new Date().getTime() - 1800 * 1000;
+function extract_cookie_policy(cookie, min_time)
+{
     let best_result = {time: -1};
     let policy = null;
     const extracted_signatures = [];
-    for (const match of document.cookie.matchAll(/hachette-(\w*)=([^;]*)/g)) {
+
+    for (const match of cookie.matchAll(/hachette-(\w*)=([^;]*)/g)) {
 	const new_result = extract_signed(...match.slice(1, 3));
 	if (new_result.fail)
 	    continue;
@@ -56,17 +57,84 @@ if (!is_privileged_url(document.URL)) {
 	policy = new_policy;
     }
 
+    return [policy, extracted_signatures];
+}
+
+function extract_url_policy(url, min_time)
+{
+    const [base_url, payload, anchor] =
+	  /^([^#]*)#?([^#]*)(#?.*)$/.exec(url).splice(1, 4);
+
+    const match = /^hachette_([^_]+)_(.*)$/.exec(payload);
+    if (!match)
+	return [null, url];
+
+    const result = extract_signed(...match.slice(1, 3));
+    if (result.fail)
+	return [null, url];
+
+    const original_url = base_url + anchor;
+    const policy = result.time < min_time ? null :
+	  JSON.parse(decodeURIComponent(result.data));
+
+    return [policy.url === original_url ? policy : null, original_url];
+}
+
+function employ_nonhttp_policy(policy)
+{
+    if (!policy.allow)
+	return;
+
+    policy.nonce = gen_nonce();
+    const [base_url, target] = /^([^#]*)(#?.*)$/.exec(policy.url).slice(1, 3);
+    const encoded_policy = encodeURIComponent(JSON.stringify(policy));
+    const payload = "hachette_" +
+	  sign_data(encoded_policy, new Date().getTime()).join("_");
+    const resulting_url = `${base_url}#${payload}${target}`;
+    location.href = resulting_url;
+    location.reload();
+}
+
+if (!is_privileged_url(document.URL)) {
+    let policy_received_callback = () => undefined;
+    let policy;
+
+    /* Signature valid for half an hour. */
+    const min_time = new Date().getTime() - 1800 * 1000;
+
+    if (/^https?:/.test(document.URL)) {
+	let signatures;
+	[policy, signatures] = extract_cookie_policy(document.cookie, min_time);
+	for (const signature of signatures)
+	    document.cookie = `hachette-${signature}=; Max-Age=-1;`;
+    } else {
+	const scheme = /^([^:]*)/.exec(document.URL)[1];
+	const known_scheme = ["file"].includes(scheme);
+
+	if (!known_scheme)
+	    console.warn(`Unknown url scheme: \`${scheme}'!`);
+
+	let original_url;
+	[policy, original_url] = extract_url_policy(document.URL, min_time);
+	history.replaceState(null, "", original_url);
+
+	if (known_scheme && !policy)
+	    policy_received_callback = employ_nonhttp_policy;
+    }
+
     if (!policy) {
-	console.warn("WARNING! Using default policy!!!");
+	console.warn("Using default policy!");
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
-    for (const signature of extracted_signatures)
-	document.cookie = `hachette-${signature}=; Max-Age=-1;`;
-
-    handle_page_actions(policy.nonce);
+    handle_page_actions(policy.nonce, policy_received_callback);
 
     if (!policy.allow) {
+	if (is_mozilla) {
+	    const script = document.querySelector("script");
+	    if (script)
+		script.textContent = "throw 'blocked';\n" + script.textContent;
+	}
 	const old_html = document.documentElement;
 	const new_html = document.createElement("html");
 	old_html.replaceWith(new_html);
diff --git a/content/page_actions.js b/content/page_actions.js
index aff56b8..6a6b3a0 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -14,10 +14,13 @@
  * IMPORTS_END
  */
 
-var port;
-var loaded = false;
-var scripts_awaiting = [];
-var nonce;
+let policy_received_callback;
+/* Snapshot url early because document.URL can be changed by other code. */
+let url;
+let port;
+let loaded = false;
+let scripts_awaiting = [];
+let nonce;
 
 function handle_message(message)
 {
@@ -31,8 +34,10 @@ function handle_message(message)
 		scripts_awaiting.push(script_text);
 	}
     }
-    if (action === "settings")
+    if (action === "settings") {
 	report_settings(data);
+	policy_received_callback({url, allow: !!data[1] && data[1].allow});
+    }
 }
 
 function document_loaded(event)
@@ -56,11 +61,14 @@ function add_script(script_text)
     report_script(script_text);
 }
 
-function handle_page_actions(script_nonce) {
+function handle_page_actions(script_nonce, policy_received_cb) {
+    policy_received_callback = policy_received_cb;
+    url = document.URL;
+
     document.addEventListener("DOMContentLoaded", document_loaded);
     port = browser.runtime.connect({name : CONNECTION_TYPE.PAGE_ACTIONS});
     port.onMessage.addListener(handle_message);
-    port.postMessage({url: document.URL});
+    port.postMessage({url});
 
     nonce = script_nonce;
 }
diff --git a/html/display-panel.js b/html/display-panel.js
index 2539ded..bc190ac 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -20,7 +20,7 @@
  * IMPORT TYPE_PREFIX
  * IMPORT nice_name
  * IMPORT open_in_settings
- * IMPORT for_each_possible_pattern
+ * IMPORT each_url_pattern
  * IMPORT by_id
  * IMPORT clone_template
  * IMPORTS_END
@@ -127,7 +127,8 @@ function handle_page_change(change)
 
 function populate_possible_patterns_list(url)
 {
-    for_each_possible_pattern(url, add_pattern_to_list);
+    for (const pattern of each_url_pattern(url))
+	add_pattern_to_list(pattern);
 
     for (const [pattern, settings] of query_all(storage, url)) {
 	set_pattern_li_button_text(ensure_pattern_exists(pattern),
-- 
cgit v1.2.3


From 48f76d7004da4bd4998d0c79266c62f893cfa7d3 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Fri, 27 Aug 2021 10:52:52 +0200
Subject: add support for `ftp://' protocol

---
 common/patterns.js | 9 ++++++++-
 content/main.js    | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'content/main.js')

diff --git a/common/patterns.js b/common/patterns.js
index 0a322b0..ebb55ab 100644
--- a/common/patterns.js
+++ b/common/patterns.js
@@ -7,6 +7,7 @@
 
 const proto_regex = /^(\w+):\/\/(.*)$/;
 
+const user_re = "[^/?#@]+@"
 const domain_re = "[^/?#]+";
 const path_re = "[^?#]*";
 const query_re = "\\??[^#]*";
@@ -15,6 +16,8 @@ const http_regex = new RegExp(`^(${domain_re})(${path_re})(${query_re}).*`);
 
 const file_regex = new RegExp(`^(${path_re}).*`);
 
+const ftp_regex = new RegExp(`^(${user_re})?(${domain_re})(${path_re}).*`);
+
 function deconstruct_url(url)
 {
     const proto_match = proto_regex.exec(url);
@@ -25,14 +28,18 @@ function deconstruct_url(url)
 
     if (deco.proto === "file") {
 	deco.path = file_regex.exec(proto_match[2])[1];
+    } else if (deco.proto === "ftp") {
+	[deco.domain, deco.path] = ftp_regex.exec(proto_match[2]).slice(2, 4);
     } else {
 	const http_match = http_regex.exec(proto_match[2]);
 	if (!http_match)
 	    return undefined;
 	[deco.domain, deco.path, deco.query] = http_match.slice(1, 4);
-	deco.domain = deco.domain.split(".");
     }
 
+    if (deco.domain)
+	deco.domain = deco.domain.split(".");
+
     const leading_dash = deco.path[0] === "/";
     deco.trailing_dash = deco.path[deco.path.length - 1] === "/";
     deco.path = deco.path.split("/").filter(s => s !== "");
diff --git a/content/main.js b/content/main.js
index 06d3bf1..6c97350 100644
--- a/content/main.js
+++ b/content/main.js
@@ -109,7 +109,7 @@ if (!is_privileged_url(document.URL)) {
 	    document.cookie = `hachette-${signature}=; Max-Age=-1;`;
     } else {
 	const scheme = /^([^:]*)/.exec(document.URL)[1];
-	const known_scheme = ["file"].includes(scheme);
+	const known_scheme = ["file", "ftp"].includes(scheme);
 
 	if (!known_scheme)
 	    console.warn(`Unknown url scheme: \`${scheme}'!`);
-- 
cgit v1.2.3


From 6247f163d3ca89d5570450ac7ac8fd18f73bb74b Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Thu, 2 Sep 2021 18:35:49 +0200
Subject: enable toggling of global script blocking policy\n\nThis commit also
 introduces `light_storage' module which is later going to replace the storage
 code we use right now.\nAlso included is a hack to properly display
 scrollbars under Mozilla (needs testing on newer Mozilla browsers).

---
 background/main.js                |   6 +-
 background/page_actions_server.js |  11 ++--
 build.sh                          |  11 ++++
 common/observable.js              |  28 ++++-----
 common/storage_light.js           | 129 ++++++++++++++++++++++++++++++++++++++
 common/storage_raw.js             |  11 +++-
 content/main.js                   |   2 +-
 content/page_actions.js           |   2 +-
 html/MOZILLA_scrollbar_fix.css    |  46 ++++++++++++++
 html/base.css                     |   8 +++
 html/default_blocking_policy.html |  18 ++++++
 html/default_blocking_policy.js   |  47 ++++++++++++++
 html/display-panel.html           |  24 ++++---
 html/display-panel.js             |   5 +-
 html/import_frame.html            |   7 +++
 html/options.html                 |   1 +
 html/options_main.js              |   3 +
 17 files changed, 322 insertions(+), 37 deletions(-)
 create mode 100644 common/storage_light.js
 create mode 100644 html/MOZILLA_scrollbar_fix.css
 create mode 100644 html/default_blocking_policy.html
 create mode 100644 html/default_blocking_policy.js

(limited to 'content/main.js')

diff --git a/background/main.js b/background/main.js
index 5d6e680..b1c252a 100644
--- a/background/main.js
+++ b/background/main.js
@@ -9,6 +9,7 @@
  * IMPORTS_START
  * IMPORT TYPE_PREFIX
  * IMPORT get_storage
+ * IMPORT light_storage
  * IMPORT start_storage_server
  * IMPORT start_page_actions_server
  * IMPORT browser
@@ -50,6 +51,7 @@ browser.runtime.onInstalled.addListener(init_ext);
 
 
 let storage;
+let policy_observable = {};
 
 function on_headers_received(details)
 {
@@ -58,7 +60,7 @@ function on_headers_received(details)
 	return;
 
     const [pattern, settings] = query_best(storage, details.url);
-    const allow = !!(settings && settings.allow);
+    const allow = !!(settings ? settings.allow : policy_observable.value);
     const nonce = gen_nonce();
     const policy = {allow, url, nonce};
 
@@ -114,6 +116,8 @@ async function start_webRequest_operations()
 	{urls: ["<all_urls>"], types: all_types},
 	extra_opts.concat("requestHeaders")
     );
+
+    policy_observable = await light_storage.observe_var("default_allow");
 }
 
 start_webRequest_operations();
diff --git a/background/page_actions_server.js b/background/page_actions_server.js
index 58a0073..b0db5f5 100644
--- a/background/page_actions_server.js
+++ b/background/page_actions_server.js
@@ -8,6 +8,7 @@
 /*
  * IMPORTS_START
  * IMPORT get_storage
+ * IMPORT light_storage
  * IMPORT TYPE_PREFIX
  * IMPORT CONNECTION_TYPE
  * IMPORT browser
@@ -20,17 +21,17 @@
 
 var storage;
 var handler;
+let policy_observable;
 
 function send_actions(url, port)
 {
-    const [pattern, settings] = query_best(storage, url);
+    let [pattern, settings] = query_best(storage, url);
+    if (!settings)
+	settings = {allow: policy_observable && policy_observable.value};
     const repos = storage.get_all(TYPE_PREFIX.REPO);
 
     port.postMessage(["settings", [pattern, settings, repos]]);
 
-    if (settings === undefined)
-	return;
-
     let components = settings.components;
     let processed_bags = new Set();
 
@@ -127,6 +128,8 @@ async function start_page_actions_server()
     storage = await get_storage();
 
     listen_for_connection(CONNECTION_TYPE.PAGE_ACTIONS, new_connection);
+
+    policy_observable = await light_storage.observe_var("default_allow");
 }
 
 /*
diff --git a/build.sh b/build.sh
index 31f3dec..0659ed1 100755
--- a/build.sh
+++ b/build.sh
@@ -291,6 +291,17 @@ EOF
     cp html/*.css $BUILDDIR/html
     mkdir $BUILDDIR/icons
     cp icons/*.png $BUILDDIR/icons
+
+    if [ "$BROWSER" = "chromium" ]; then
+	for MOZILLA_FILE in $(find $BUILDDIR -name "MOZILLA_*"); do
+	    echo > "$MOZILLA_FILE"
+	done
+    fi
+    if [ "$BROWSER" = "mozilla" ]; then
+	for CHROMIUM_FILE in $(find $BUILDDIR -name "CHROMIUM_*"); do
+	    echo > "$CHROMIUM_FILE"
+	done
+    fi
 }
 
 main "$@"
diff --git a/common/observable.js b/common/observable.js
index 1fb0b0a..02f1c1b 100644
--- a/common/observable.js
+++ b/common/observable.js
@@ -6,28 +6,22 @@
  * Redistribution terms are gathered in the `copyright' file.
  */
 
-function make()
-{
-    return new Set();
-}
+const make = (value=undefined) => ({value, listeners: new Set()});
+const subscribe = (observable, cb) => observable.listeners.add(cb);
+const unsubscribe = (observable, cb) => observable.listeners.delete(cb);
 
-function subscribe(observable, cb)
-{
-    observable.add(cb);
-}
-
-function unsubscribe(observable, cb)
-{
-    observable.delete(cb);
-}
+const silent_set = (observable, value) => observable.value = value;
+const broadcast = (observable, ...values) =>
+      observable.listeners.forEach(cb => cb(...values));
 
-function broadcast(observable, event)
+function set(observable, value)
 {
-    for (const callback of observable)
-	callback(event);
+    const old_value = observable.value;
+    silent_set(observable, value);
+    broadcast(observable, value, old_value);
 }
 
-const observables = {make, subscribe, unsubscribe, broadcast};
+const observables = {make, subscribe, unsubscribe, broadcast, silent_set, set};
 
 /*
  * EXPORTS_START
diff --git a/common/storage_light.js b/common/storage_light.js
new file mode 100644
index 0000000..067bf0c
--- /dev/null
+++ b/common/storage_light.js
@@ -0,0 +1,129 @@
+/**
+ * part of Hachette
+ * Storage manager, lighter than the previous one.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * IMPORTS_START
+ * IMPORT TYPE_PREFIX
+ * IMPORT raw_storage
+ * IMPORT is_mozilla
+ * IMPORT observables
+ */
+
+const reg_spec = new Set(["\\", "[", "]", "(", ")", "{", "}", ".", "*", "+"]);
+const escape_reg_special = c => reg_spec.has(c) ? "\\" + c : c;
+
+function make_regex(name)
+{
+    return new RegExp(`^${name.split("").map(escape_reg_special).join("")}\$`);
+}
+
+const listeners_by_callback = new Map();
+
+function listen(callback, prefix, name)
+{
+    let by_prefix = listeners_by_callback.get(callback);
+    if (!by_prefix) {
+	by_prefix = new Map();
+	listeners_by_callback.set(callback, by_prefix);
+    }
+
+    let by_name = by_prefix.get(prefix);
+    if (!by_name) {
+	by_name = new Map();
+	by_prefix.set(prefix, by_name);
+    }
+
+    let name_reg = by_name.get(name);
+    if (!name_reg) {
+	name_reg = name.test ? name : make_regex(name);
+	by_name.set(name, name_reg);
+    }
+}
+
+function no_listen(callback, prefix, name)
+{
+    const by_prefix = listeners_by_callback.get(callback);
+    if (!by_prefix)
+	return;
+
+    const by_name = by_prefix.get(prefix);
+    if (!by_name)
+	return;
+
+    const name_reg = by_name.get(name);
+    if (!name_reg)
+	return;
+
+    by_name.delete(name);
+
+    if (by_name.size === 0)
+	by_prefix.delete(prefix);
+
+    if (by_prefix.size === 0)
+	listeners_by_callback.delete(callback);
+}
+
+function storage_change_callback(changes, area)
+{
+    if (is_mozilla && area !== "local")
+    {console.log("area", area);return;}
+
+    for (const item of Object.keys(changes)) {
+	for (const [callback, by_prefix] of listeners_by_callback.entries()) {
+	    const by_name = by_prefix.get(item[0]);
+	    if (!by_name)
+		continue;
+
+	    for (const reg of by_name.values()) {
+		if (!reg.test(item.substring(1)))
+		    continue;
+
+		try {
+		    callback(item, changes[item]);
+		} catch(e) {
+		    console.error(e);
+		}
+	    }
+	}
+    }
+}
+
+raw_storage.listen(storage_change_callback);
+
+
+const created_observables = new Map();
+
+async function observe(prefix, name)
+{
+    const observable = observables.make();
+    const callback = (it, ch) => observables.set(observable, ch.newValue);
+    listen(callback, prefix, name);
+    created_observables.set(observable, [callback, prefix, name]);
+    observables.silent_set(observable, await raw_storage.get(prefix + name));
+
+    return observable;
+}
+
+const observe_var = name => observe(TYPE_PREFIX.VAR, name);
+
+function no_observe(observable)
+{
+    no_listen(...created_observables.get(observable) || []);
+    created_observables.delete(observable);
+}
+
+const light_storage = {};
+Object.assign(light_storage, raw_storage);
+Object.assign(light_storage,
+	      {listen, no_listen, observe, observe_var, no_observe});
+
+/*
+ * EXPORTS_START
+ * EXPORT light_storage
+ * EXPORTS_END
+ */
diff --git a/common/storage_raw.js b/common/storage_raw.js
index 9ce3980..4c02ee4 100644
--- a/common/storage_raw.js
+++ b/common/storage_raw.js
@@ -26,8 +26,9 @@ async function get(key)
 
 async function set(key_or_object, value)
 {
-    return browser.storage.local.set(typeof key_or_object === "object" ?
-				     key_or_object : {[key]: value});
+    const arg = typeof key_or_object === "object" ?
+	  key_or_object : {[key_or_object]: value};
+    return browser.storage.local.set(arg);
 }
 
 async function set_var(name, value)
@@ -40,7 +41,11 @@ async function get_var(name)
     return get(TYPE_PREFIX.VAR + name);
 }
 
-const raw_storage = {get, set, get_var, set_var};
+const on_changed = browser.storage.onChanged || browser.storage.local.onChanged;
+const listen = cb => on_changed.addListener(cb);
+const no_listen = cb => on_changed.removeListener(cb);
+
+const raw_storage = {get, set, get_var, set_var, listen, no_listen};
 
 /*
  * EXPORTS_START
diff --git a/content/main.js b/content/main.js
index 6c97350..17b6b98 100644
--- a/content/main.js
+++ b/content/main.js
@@ -123,7 +123,7 @@ if (!is_privileged_url(document.URL)) {
     }
 
     if (!policy) {
-	console.warn("Using default policy!");
+	console.warn("Using fallback policy!");
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
diff --git a/content/page_actions.js b/content/page_actions.js
index 6a6b3a0..bf76790 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -36,7 +36,7 @@ function handle_message(message)
     }
     if (action === "settings") {
 	report_settings(data);
-	policy_received_callback({url, allow: !!data[1] && data[1].allow});
+	policy_received_callback({url, allow: data[1].allow});
     }
 }
 
diff --git a/html/MOZILLA_scrollbar_fix.css b/html/MOZILLA_scrollbar_fix.css
new file mode 100644
index 0000000..5feb7c3
--- /dev/null
+++ b/html/MOZILLA_scrollbar_fix.css
@@ -0,0 +1,46 @@
+/**
+ * Hachette
+ * Hacky fix for vertical scrollbar width being included in child's width.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * Under Mozilla browsers to avoid vertical scrollbar forcing horizontal
+ * scrollbar to appear in an element we add the `firefox_scrollbars_hacky_fix'
+ * class to an element for which width has to be reserved.
+ *
+ * This is a bit hacky and relies on some assumed width of Firefox scrollbar, I
+ * know. And must be excluded from Chromium builds.
+ *
+ * I came up with this hack when working on popup. Before that I had the
+ * scrollbar issue with tables in the options page and gave up there and made
+ * the scrollbal always visible. Now we could try applying this "fix" there,
+ * too!
+ */
+
+.firefox_scrollbars_hacky_fix {
+    font-size: 0;
+}
+
+.firefox_scrollbars_hacky_fix>div {
+    display: inline-block;
+    width: -moz-available;
+}
+
+.firefox_scrollbars_hacky_fix>*>* {
+    font-size: initial;
+}
+
+.firefox_scrollbars_hacky_fix::after {
+    content: "";
+    display: inline-block;
+    visibility: hidden;
+    font-size: initial;
+    width: 14px;
+}
+
+.firefox_scrollbars_hacky_fix.has_inline_content::after {
+    width: calc(14px - 0.3em);
+}
diff --git a/html/base.css b/html/base.css
index 94b3f31..df52f7c 100644
--- a/html/base.css
+++ b/html/base.css
@@ -100,6 +100,14 @@ textarea: {
     background: linear-gradient(#555, transparent);
 }
 
+.has_bottom_thin_line {
+    border-bottom: dashed #4CAF50 1px;
+}
+
+.has_upper_thin_line {
+    border-top: dashed #4CAF50 1px;
+}
+
 .nowrap {
     white-space: nowrap;
 }
diff --git a/html/default_blocking_policy.html b/html/default_blocking_policy.html
new file mode 100644
index 0000000..50c19ca
--- /dev/null
+++ b/html/default_blocking_policy.html
@@ -0,0 +1,18 @@
+<!--
+    Copyright (C) 2021 Wojtek Kosior
+    Redistribution terms are gathered in the `copyright' file.
+
+    This is not a standalone page. This file is meant to be imported into other
+    HTML code.
+  -->
+<style>
+  #blocking_policy_div {
+      line-height: 2em;
+  }
+</style>
+<span id="blocking_policy_span">
+  Default policy for unmatched pages is to
+  <span id="current_policy_span" class="bold"></span>
+  their own scripts.
+  <button id="toggle_policy_but">Toggle policy</button>
+</span>
diff --git a/html/default_blocking_policy.js b/html/default_blocking_policy.js
new file mode 100644
index 0000000..2f49bac
--- /dev/null
+++ b/html/default_blocking_policy.js
@@ -0,0 +1,47 @@
+/**
+ * part of Hachette
+ * Default policy dialog logic.
+ *
+ * Copyright (C) 2021 Wojtek Kosior
+ * Redistribution terms are gathered in the `copyright' file.
+ */
+
+/*
+ * IMPORTS_START
+ * IMPORT by_id
+ * IMPORT light_storage
+ * IMPORT observables
+ * IMPORTS_END
+ */
+
+/*
+ * Used with `default_blocking_policy.html' to allow user to choose whether to
+ * block scripts globally or not.
+ */
+
+const blocking_policy_span = by_id("blocking_policy_span");
+const current_policy_span = by_id("current_policy_span");
+const toggle_policy_but = by_id("toggle_policy_but");
+
+let policy_observable;
+
+const update_policy =
+      allowed => current_policy_span.textContent = allowed ? "allow" : "block";
+const toggle_policy =
+      () => light_storage.set_var("default_allow", !policy_observable.value);
+
+async function init_default_policy_dialog()
+{
+    policy_observable = await light_storage.observe_var("default_allow");
+    update_policy(policy_observable.value);
+    observables.subscribe(policy_observable, update_policy);
+
+    toggle_policy_but.addEventListener("click", toggle_policy);
+    blocking_policy_span.classList.remove("hide");
+}
+
+/*
+ * EXPORTS_START
+ * EXPORT init_default_policy_dialog
+ * EXPORTS_END
+ */
diff --git a/html/display-panel.html b/html/display-panel.html
index 0806f26..a8c52b6 100644
--- a/html/display-panel.html
+++ b/html/display-panel.html
@@ -11,10 +11,11 @@
     <link type="text/css" rel="stylesheet" href="base.css" />
     <link type="text/css" rel="stylesheet" href="back_button.css" />
     <link type="text/css" rel="stylesheet" href="table.css" />
+    <link type="text/css" rel="stylesheet" href="MOZILLA_scrollbar_fix.css" />
     <style>
       body {
 	  width: max-content;
-	  width: -moz-max-content;
+	  width: -moz-fit-content;
       }
 
       .top>h2 {
@@ -114,8 +115,6 @@
       pre {
 	  font-family: monospace;
 	  background-color: white;
-	  border-top: dashed #4CAF50 1px;
-	  border-bottom: dashed #4CAF50 1px;
 	  padding: 1px 5px;
       }
 
@@ -133,8 +132,11 @@
 	  padding-right: 5px;
       }
 
+      .padding_top {
+	  padding-top: 5px;
+      }
+
       .header {
-	  border-bottom: dashed #4CAF50 1px;
 	  padding-bottom: 0.3em;
 	  margin-bottom: 0.5em;
 	  text-align: center;
@@ -146,7 +148,6 @@
       }
 
       .footer {
-	  border-top: dashed #4CAF50 1px;
 	  padding-top: 0.3em;
 	  margin-top: 0.5em;
 	  text-align: center;
@@ -199,7 +200,7 @@
 	  <label data-template="lbl">
 	    <h3><div class="unroll_triangle"></div> script</h3>
 	  </label>
-	  <pre data-template="script_contents"></pre>
+	  <pre class="has_bottom_thin_line has_upper_thin_line" data-template="script_contents"></pre>
 	</div>
       </div>
 
@@ -242,7 +243,7 @@
 	  Patterns higher are more specific and override the ones below.
 	</aside>
       </div>
-      <div class="table_wrapper">
+      <div class="table_wrapper firefox_scrollbars_hacky_fix">
 	<div>
 	  <table>
 	    <tbody id="possible_patterns">
@@ -250,6 +251,11 @@
 	  </table>
 	</div>
       </div>
+      <div class="padding_inline padding_top has_upper_thin_line firefox_scrollbars_hacky_fix has_inline_content">
+	<span class="nowrap">
+	  <IMPORT html/default_blocking_policy.html />
+	</span>
+      </div>
     </div>
 
     <input id="show_queried_view_radio" type="radio" class="show_next" name="current_view"></input>
@@ -265,7 +271,7 @@
       <h3 id="privileged_notice" class="middle hide">Privileged page</h3>
 
       <div id="page_state" class="hide">
-	<div class="header padding_inline">
+	<div class="header padding_inline has_bottom_thin_line">
 	  <label for="show_patterns_view_radio" class="button">
 	    Edit settings for this page
 	  </label>
@@ -317,7 +323,7 @@
 	</div>
       </div>
 
-      <div class="footer padding_inline">
+      <div class="footer padding_inline has_upper_thin_line">
 	<button id="settings_but" type="button">
 	  Open Hachette settings
 	</button>
diff --git a/html/display-panel.js b/html/display-panel.js
index bd210c1..ed96c07 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -14,6 +14,7 @@
  *** temporarily, before all storage access gets reworked.
  * IMPORT get_remote_storage
  * IMPORT get_import_frame
+ * IMPORT init_default_policy_dialog
  * IMPORT query_all
  * IMPORT CONNECTION_TYPE
  * IMPORT is_privileged_url
@@ -243,7 +244,6 @@ function handle_activity_report(message)
     if (type === "settings") {
 	let [pattern, settings] = data;
 
-	settings = settings || {};
 	blocked_span.textContent = settings.allow ? "no" : "yes";
 
 	if (pattern) {
@@ -254,6 +254,7 @@ function handle_activity_report(message)
 	    view_pattern_but.addEventListener("click", settings_opener);
 	} else {
 	    pattern_span.textContent = "none";
+	    blocked_span.textContent = blocked_span.textContent + " (default)";
 	}
 
 	const components = settings.components;
@@ -549,6 +550,8 @@ by_id("settings_but")
 
 async function main()
 {
+    init_default_policy_dialog();
+
     storage = await get_remote_storage();
     import_frame = await get_import_frame();
     import_frame.onclose = () => show_queried_view_radio.checked = true;
diff --git a/html/import_frame.html b/html/import_frame.html
index e6db205..754b289 100644
--- a/html/import_frame.html
+++ b/html/import_frame.html
@@ -1,3 +1,10 @@
+<!--
+    Copyright (C) 2021 Wojtek Kosior
+    Redistribution terms are gathered in the `copyright' file.
+
+    This is not a standalone page. This file is meant to be imported into other
+    HTML code.
+  -->
 <style>
   .padding_right {
       padding-right: 0.3em;
diff --git a/html/options.html b/html/options.html
index 085162c..f2a75e1 100644
--- a/html/options.html
+++ b/html/options.html
@@ -248,6 +248,7 @@
 	</div>
       </div>
       <button id="add_page_but" type="button"> Add page </button>
+      <IMPORT html/default_blocking_policy.html />
     </div>
     <div id="bags" class="tab">
       <div class="table_wrapper tight_table has_bottom_line has_upper_line">
diff --git a/html/options_main.js b/html/options_main.js
index e08bdb9..2f4f154 100644
--- a/html/options_main.js
+++ b/html/options_main.js
@@ -17,6 +17,7 @@
  * IMPORT by_id
  * IMPORT matchers
  * IMPORT get_import_frame
+ * IMPORT init_default_policy_dialog
  * IMPORTS_END
  */
 
@@ -670,6 +671,8 @@ function jump_to_item(url_with_item)
 
 async function main()
 {
+    init_default_policy_dialog();
+
     storage = await get_remote_storage();
 
     for (let prefix of list_prefixes) {
-- 
cgit v1.2.3


From 44958e6ab4218429475f3c79ecf2116b78a07021 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Thu, 2 Sep 2021 21:32:48 +0200
Subject: implement rethinked <meta> tags sanitizing approach

This has not been tested yet. Additionally, functionality for blocking of `data:' urls needs to be re-enabled.
---
 common/misc.js               |   2 +-
 content/main.js              | 155 +++++++++++++++++--
 content/sanitize_document.js | 344 -------------------------------------------
 3 files changed, 144 insertions(+), 357 deletions(-)
 delete mode 100644 content/sanitize_document.js

(limited to 'content/main.js')

diff --git a/common/misc.js b/common/misc.js
index 8894d60..30a9e77 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -178,7 +178,7 @@ function sanitize_csp_header(header, policy)
     return {name: header.name, value: new_csp.join('')};
 }
 
-/* Regexes and objest to use as/in schemas for parse_json_with_schema(). */
+/* Regexes and objects to use as/in schemas for parse_json_with_schema(). */
 const nonempty_string_matcher = /.+/;
 
 const matchers = {
diff --git a/content/main.js b/content/main.js
index 4ae7738..8440eb5 100644
--- a/content/main.js
+++ b/content/main.js
@@ -16,7 +16,9 @@
  * IMPORT is_chrome
  * IMPORT is_mozilla
  * IMPORT start_activity_info_server
- * IMPORT modify_on_the_fly
+ * IMPORT csp_rule
+ * IMPORT is_csp_header_name
+ * IMPORT sanitize_csp_header
  * IMPORTS_END
  */
 
@@ -31,6 +33,143 @@ function accept_node(node, parent)
     parent.hachette_corresponding.appendChild(clone);
 }
 
+/*
+ * 1. When injecting some payload we need to sanitize <meta> CSP tags before
+ *    they reach the document.
+ * 2. Only <meta> tags inside <head> are considered valid by the browser and
+ *    need to be considered.
+ * 3. We want to detach <html> from document, wait until its <head> completes
+ *    loading, sanitize it and re-attach <html>.
+ * 4. Browsers are eager to add <meta>'s that appear after `</head>' but before
+ *    `<body>'. Due to this behavior the `DOMContentLoaded' event is considered
+ *    unreliable (although it could still work properly, it is just problematic
+ *    to verify).
+ * 5. We shall wait for anything to appear in or after <body> and take that as
+ *    a sign <head> has _really_ finished loading.
+ */
+
+function make_body_start_observer(DOM_element, waiting)
+{
+    const observer = new MutationObserver(() => try_body_started(waiting));
+    observer.observe(DOM_element, {childList: true});
+    return observer;
+}
+
+function try_body_started(waiting)
+{
+    const body = waiting.detached_html.querySelector("body");
+
+    if ((body && (body.firstChild || body.nextSibling)) ||
+	waiting.doc.documentElement.nextSibling) {
+	finish_waiting(waiting);
+	return true;
+    }
+
+    if (body && waiting.observers.length < 2)
+	waiting.observers.push(make_body_start_observer(body, waiting));
+}
+
+function finish_waiting(waiting)
+{
+    waiting.observers.forEach(observer => observer.disconnect());
+    waiting.doc.removeEventListener("DOMContentLoaded", waiting.loaded_cb);
+    setTimeout(waiting.callback, 0);
+}
+
+function _wait_for_head(doc, detached_html, callback)
+{
+    const waiting = {doc, detached_html, callback, observers: []};
+    if (try_body_started(waiting))
+	return;
+
+    waiting.observers = [make_body_start_observer(detached_html, waiting)];
+    waiting.loaded_cb = () => finish_waiting(waiting);
+    doc.addEventListener("DOMContentLoaded", waiting.loaded_cb);
+}
+
+function wait_for_head(doc, detached_html)
+{
+    return new Promise(cb => _wait_for_head(doc, detached_html, cb));
+}
+
+const blocked_str = "blocked";
+
+function block_attribute(node, attr)
+{
+    /*
+     * Disabling attributes this way allows them to still be relatively
+     * easily accessed in case they contain some useful data.
+     */
+    const construct_name = [attr];
+    while (node.hasAttribute(construct_name.join("")))
+	construct_name.unshift(blocked_str);
+
+    while (construct_name.length > 1) {
+	construct_name.shift();
+	const name = construct_name.join("");
+	node.setAttribute(`${blocked_str}-${name}`, node.getAttribute(name));
+    }
+
+    node.removeAttribute(attr);
+}
+
+function sanitize_meta(meta, policy)
+{
+    const http_equiv = meta.getAttribute("http-equiv");
+    const value = meta.content;
+
+    if (!value || !is_csp_header_name(http_equiv, true))
+	return;
+
+    block_attribute(meta, "content");
+
+    if (is_csp_header_name(http_equiv, false))
+	meta.content = sanitize_csp_header({value}, policy).value;
+}
+
+function apply_hachette_csp_rules(doc, policy)
+{
+    const meta = doc.createElement("meta");
+    meta.setAttribute("http-equiv", "Content-Security-Policy");
+    meta.setAttribute("content", csp_rule(policy.nonce));
+    doc.head.append(meta);
+    /* CSP is already in effect, we can remove the <meta> now. */
+    meta.remove();
+}
+
+async function sanitize_document(doc, policy)
+{
+    /*
+     * Ensure our CSP rules are employed from the beginning. This CSP injection
+     * method is, when possible, going to be applied together with CSP rules
+     * injected using webRequest.
+     */
+    const has_own_head = doc.head;
+    if (!has_own_head)
+	doc.documentElement.prepend(doc.createElement("head"));
+
+    apply_hachette_csp_rules(doc, policy);
+
+    /* Probably not needed, but...: proceed with DOM in its initial state. */
+    if (!has_own_head)
+	doc.head.remove();
+
+    /*
+     * <html> node gets hijacked now, to be re-attached after <head> is loaded
+     * and sanitized.
+     */
+    const old_html = doc.documentElement;
+    const new_html = doc.createElement("html");
+    old_html.replaceWith(new_html);
+
+    await wait_for_head(doc, old_html);
+
+    for (const meta of old_html.querySelectorAll("head meta"))
+	sanitize_meta(meta, policy);
+
+    new_html.replaceWith(old_html);
+}
+
 if (!is_privileged_url(document.URL)) {
     const reductor =
 	  (ac, [_, sig, pol]) => ac[0] && ac || [extract_signed(sig, pol), sig];
@@ -45,18 +184,10 @@ if (!is_privileged_url(document.URL)) {
     if (signature)
 	document.cookie = `hachette-${signature}=; Max-Age=-1;`;
 
-    handle_page_actions(policy.nonce);
+    if (!policy.allow)
+	sanitize_document(document, policy);
 
-    if (!policy.allow) {
-	const old_html = document.documentElement;
-	const new_html = document.createElement("html");
-	old_html.replaceWith(new_html);
-	old_html.hachette_corresponding = new_html;
-
-	const modify_end =
-	      modify_on_the_fly(old_html, policy, {node_eater: accept_node});
-	document.addEventListener("DOMContentLoaded", modify_end);
-    }
+    handle_page_actions(policy.nonce);
 
     start_activity_info_server();
 }
diff --git a/content/sanitize_document.js b/content/sanitize_document.js
deleted file mode 100644
index 727bb6c..0000000
--- a/content/sanitize_document.js
+++ /dev/null
@@ -1,344 +0,0 @@
-/**
- * Hachette modify HTML document as it loads and reconstruct HTML code from it
- *
- * Copyright (C) 2021 Wojtek Kosior
- * Redistribution terms are gathered in the `copyright' file.
- */
-
-/*
- * IMPORTS_START
- * IMPORT gen_nonce
- * IMPORT csp_rule
- * IMPORT is_csp_header_name
- * IMPORT sanitize_csp_header
- * IMPORT sanitize_attributes
- * IMPORTS_END
- */
-
-/*
- * Functions that sanitize elements. The script blocking measures are, when
- * possible, going to be applied together with CSP rules injected using
- * webRequest.
- */
-
-const blocked = "blocked";
-
-function block_attribute(node, attr)
-{
-    /*
-     * Disabling attributed this way allows them to still be relatively
-     * easily accessed in case they contain some useful data.
-     */
-
-    const construct_name = [attr];
-    while (node.hasAttribute(construct_name.join("")))
-	construct_name.unshift(blocked);
-
-    while (construct_name.length > 1) {
-	construct_name.shift();
-	const name = construct_name.join("");
-	node.setAttribute(`${blocked}-${name}`, node.getAttribute(name));
-    }
-
-    node.removeAttribute(attr);
-}
-
-function sanitize_script(script, data)
-{
-    if (script.getAttribute("data-hachette-deleteme") === data.policy.nonce) {
-	script.remove();
-	script.hachette_deleted = true;
-	script.hachette_ignore = true;
-    }
-
-    if (data.policy.allow)
-	return;
-
-    block_attribute(script, "type");
-    script.setAttribute("type", "application/json");
-}
-
-function inject_csp(head, data)
-{
-    if (data.policy.allow)
-	return;
-
-    const meta = document.createElement("meta");
-    meta.setAttribute("http-equiv", "Content-Security-Policy");
-    meta.setAttribute("content", csp_rule(data.policy.nonce));
-    meta.hachette_ignore = true;
-    head.prepend(meta);
-
-    data.new_added.unshift([meta, head]);
-}
-
-function sanitize_http_equiv_csp_rule(meta, data)
-{
-    const http_equiv = meta.getAttribute("http-equiv");
-    const value = meta.content;
-
-    if (!value || !is_csp_header_name(http_equiv, !data.policy.allow))
-	return;
-
-    block_attribute(meta, "content");
-
-    if (data.policy.allow || is_csp_header_name(http_equiv, false))
-	meta.content = sanitize_csp_header({value}, data.policy).value;
-}
-
-function sanitize_node(node, data)
-{
-    if (node.tagName === "SCRIPT")
-	sanitize_script(node, data);
-
-    if (node.tagName === "HEAD")
-	inject_csp(node, data);
-
-    if (node.tagName === "META")
-	sanitize_http_equiv_csp_rule(node, data);
-
-    if (!data.policy.allow)
-	sanitize_attributes(node, data);
-}
-
-/*
- * Instead of calling writer directly with multiple small chunks of reconstruced
- * HTML code, we utilize `setTimeout()' to only have it called once,
- * asynchronously.
- */
-function do_write_callback(data)
-{
-    data.writer(data.chunks.join(""));
-    data.chunks = [];
-
-    if (data.finished && data.finisher)
-	data.finisher();
-}
-
-function do_write(chunk, data)
-{
-    data.chunks.push(chunk);
-    clearTimeout(data.write_timeout);
-    data.write_timeout = setTimeout(() => do_write_callback(data), 0);
-}
-
-const serializer = new XMLSerializer();
-
-function start_serializing_node(node, data)
-{
-    node.hachette_started = true;
-
-    if (!data.writer)
-	return;
-
-    const clone = node.cloneNode(false);
-    clone.textContent = data.uniq;
-    do_write(data.uniq_reg.exec(clone.outerHTML)[1], data);
-}
-
-function finish_serializing_node(node, data)
-{
-    const nodes_to_process = [node];
-
-    while (true) {
-	node = nodes_to_process.pop();
-	if (!node)
-	    break;
-
-	nodes_to_process.push(node, node.hachette_last_added);
-    }
-
-    while (nodes_to_process.length > 0) {
-	const node = nodes_to_process.pop();
-	node.remove();
-	node.hachette_ignore = true;
-
-	if (!data.writer)
-	    continue;
-
-	if (node.hachette_started) {
-	    node.textContent = data.uniq;
-	    do_write(data.uniq_reg.exec(node.outerHTML)[2], data);
-	    continue;
-	}
-
-	do_write(node.outerHTML || serializer.serializeToString(node), data);
-    }
-}
-
-function process_initial_nodes(node, data)
-{
-    if (data.processed_initial_nodes)
-	return;
-
-    data.processed_initial_nodes = true;
-
-    start_serializing_node(data.html_root, data);
-
-    const new_added = [];
-    const nodes_to_process = [data.html_root];
-
-    let i = 0;
-    while (nodes_to_process.length > 0) {
-	let current = nodes_to_process.shift();
-
-	if (current.firstChild) {
-	    if (current.firstChild === node)
-		break;
-	    nodes_to_process.unshift(current.firstChild, current);
-	    new_added.push([current.firstChild, current]);
-	    continue;
-	}
-
-	while (current && !current.nextSibling)
-	    current = nodes_to_process.shift();
-
-	if (!current || current.nextSibling === node)
-	    break;
-
-	nodes_to_process.unshift(current.nextSibling);
-	new_added.push([current.nextSibling, nodes_to_process[1]]);
-    }
-
-    data.new_added.unshift(...new_added);
-}
-
-/*
- * Important! Due to some weirdness node.parentElement is not alway correct
- * in MutationRecords under Chromium. Track node relations manually.
- */
-function handle_added_node(node, true_parent, data)
-{
-    /*
-     * Functions we call here might cause new nodes to be injected or found
-     * that require processing before the one we got in function argument.
-     * We rely on those functions putting the node(s) they create/find at the
-     * very beginning of the `new_added' queue and (for created nodes) setting
-     * their `hachette_ignore' property, based on which their MutationRecord
-     * will not be processed. A function can also mark a node already in the
-     * `new_added' queue as not eligible for processing by setting its
-     * `hachette_deleted' property.
-     */
-
-    process_initial_nodes(node, data);
-
-    data.new_added.push([node, true_parent]);
-
-    while (data.new_added.length > 0) {
-	[node, true_parent] = data.new_added.shift();
-
-	if (true_parent.hachette_deleted)
-	    node.hachette_deleted = true;
-	if (node.hachette_deleted)
-	    continue;
-
-	if (!true_parent.hachette_started)
-	    start_serializing_node(true_parent, data)
-
-	if (!node.hachette_ignore)
-	    sanitize_node(node, data);
-
-	if (node.hachette_deleted)
-	    continue;
-
-	if (data.node_eater)
-	    data.node_eater(node, true_parent);
-
-	finish_serializing_node(true_parent.hachette_last_added, data);
-
-	true_parent.hachette_last_added = node;
-    }
-}
-
-function handle_mutation(mutations, data)
-{
-    /*
-     * Chromium: for an unknown reason mutation.target is not always the same as
-     * node.parentElement. The former is the correct one.
-     */
-    for (const mutation of mutations) {
-	for (const node of mutation.addedNodes) {
-	    /* Check for nodes added by ourselves. */
-	    if (mutation.target.hachette_ignore)
-		node.hachette_ignore = true;
-	    if (node.hachette_ignore)
-		continue;
-
-	    handle_added_node(node, mutation.target, data);
-	}
-    }
-}
-
-function finish_processing(data)
-{
-    process_initial_nodes(undefined, data);
-
-    /*
-     * The `finisher' callback should be called, if provided. Normally our
-     * function that performs the last write does it after seeing `finished'
-     * set to `true'. If, however, there's no `writer' callback and hence no
-     * writes to perform, we need to take care of calling `finisher' here.
-     */
-    data.finished = true;
-    handle_mutation(data.observer.takeRecords(), data);
-    data.observer.disconnect();
-
-    /*
-     * Additional whitespace that was after `</body>' gets appended to body.
-     * Although it's a minor issue, it is not what we want. There's no way to
-     * tell exactly what part of that whitespace was after `</body>' and what
-     * was before, so we just replace it with a single newline which looks good
-     * when printed.
-     */
-    const body = data.html_root.lastChild;
-    const text = body && body.tagName === "BODY" && body.lastChild;
-    if (text && text.nodeName === "#text") {
-	const new_content = /^([\S\s]*\S)?\s*$/.exec(text.textContent)[1] || "";
-	text.textContent = new_content + "\n";
-    }
-
-    finish_serializing_node(data.html_root, data);
-    if (!data.writer && data.finisher)
-	setTimeout(data.finisher, 0);
-}
-
-/*
- * This function sanitizes `html_root' according to `policy'. It is capable of
- * working on an HTML document that is being written to, sanitizing new nodes
- * as they appear.
- *
- * `consumers' object may contain 3 optional callback functions: `writer',
- * `node_eater' and `finisher'. The first one, if present, is called with chunks
- * of reconstructed HTML code. The second one, if present, gets called for every
- * added node with 2 arguments: that node and its parent. The third one is
- * called at the end, after all processing has been done.
- *
- * `modify_on_the_fly()' returns a callback that should be called (with no
- * arguments) once the document of html_root has finished being written to.
- * Unfortunately, due to specifics behavior of document that has had its
- * documentElement replaced
- */
-function modify_on_the_fly(html_root, policy, consumers)
-{
-    const uniq = gen_nonce();
-    const uniq_reg = new RegExp(`^([\\s\\S]*)${uniq}([\\s\\S]*)$`);
-    const data = {policy, html_root, uniq, uniq_reg, chunks: [], new_added: []};
-    Object.assign(data, consumers);
-
-    var observer = new MutationObserver(m => handle_mutation(m, data));
-    observer.observe(data.html_root, {
-     	attributes: true,
-	childList: true,
-	subtree: true
-    });
-
-    data.observer = observer;
-
-    return () => finish_processing(data);
-}
-
-/*
- * EXPORTS_START
- * EXPORT modify_on_the_fly
- * EXPORTS_END
- */
-- 
cgit v1.2.3


From c12b9ee3535f5a4515c164b020dfc08df8f1bfbd Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Fri, 3 Sep 2021 19:40:45 +0200
Subject: disable payload injection on non-html pages

---
 content/activity_info_server.js | 6 ++++++
 content/main.js                 | 2 ++
 content/page_actions.js         | 9 ++++++++-
 html/display-panel.html         | 5 +++++
 html/display-panel.js           | 5 +++++
 5 files changed, 26 insertions(+), 1 deletion(-)

(limited to 'content/main.js')

diff --git a/content/activity_info_server.js b/content/activity_info_server.js
index 81a25fb..beecb1a 100644
--- a/content/activity_info_server.js
+++ b/content/activity_info_server.js
@@ -44,6 +44,11 @@ function report_settings(settings)
     report_activity("settings", settings);
 }
 
+function report_content_type(content_type)
+{
+    report_activity("content_type", content_type);
+}
+
 function report_repo_query_action(update, port)
 {
     report_activity_oneshot("repo_query_action", update, port);
@@ -91,5 +96,6 @@ function start_activity_info_server()
  * EXPORT start_activity_info_server
  * EXPORT report_script
  * EXPORT report_settings
+ * EXPORT report_content_type
  * EXPORTS_END
  */
diff --git a/content/main.js b/content/main.js
index 17b6b98..da215b9 100644
--- a/content/main.js
+++ b/content/main.js
@@ -147,3 +147,5 @@ if (!is_privileged_url(document.URL)) {
 
     start_activity_info_server();
 }
+
+console.log("content script");
diff --git a/content/page_actions.js b/content/page_actions.js
index bf76790..3799afd 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -11,12 +11,14 @@
  * IMPORT browser
  * IMPORT report_script
  * IMPORT report_settings
+ * IMPORT report_content_type
  * IMPORTS_END
  */
 
 let policy_received_callback;
-/* Snapshot url early because document.URL can be changed by other code. */
+/* Snapshot url and content type early; these can be changed by other code. */
 let url;
+let is_html;
 let port;
 let loaded = false;
 let scripts_awaiting = [];
@@ -52,6 +54,9 @@ function document_loaded(event)
 
 function add_script(script_text)
 {
+    if (!is_html)
+	return;
+
     let script = document.createElement("script");
     script.textContent = script_text;
     script.setAttribute("nonce", nonce);
@@ -64,6 +69,8 @@ function add_script(script_text)
 function handle_page_actions(script_nonce, policy_received_cb) {
     policy_received_callback = policy_received_cb;
     url = document.URL;
+    is_html = /html/.test(document.contentType);
+    report_content_type(document.contentType);
 
     document.addEventListener("DOMContentLoaded", document_loaded);
     port = browser.runtime.connect({name : CONNECTION_TYPE.PAGE_ACTIONS});
diff --git a/html/display-panel.html b/html/display-panel.html
index a8c52b6..1f6beb7 100644
--- a/html/display-panel.html
+++ b/html/display-panel.html
@@ -306,6 +306,11 @@
 		    </label>
 		  </td>
 		</tr>
+		<tr>
+		  <td id="content_type" colspan="3" class="hide">
+		    This is a non-HTML page. Chosen payload will not be injected.
+		  </td>
+		</tr>
 	      </tbody>
 	    </table>
 	    <label id="query_pattern" for="show_queried_view_radio" class="button">
diff --git a/html/display-panel.js b/html/display-panel.js
index ed96c07..66e51a6 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -230,6 +230,7 @@ const payload_buttons_div = by_id("payload_buttons");
 const view_payload_but = by_id("view_payload");
 const view_injected_but = by_id("view_injected");
 const container_for_injected = by_id("container_for_injected");
+const content_type_cell = by_id("content_type");
 
 const queried_items = new Map();
 
@@ -275,6 +276,10 @@ function handle_activity_report(message)
 	template.script_contents.textContent = data;
 	container_for_injected.appendChild(template.div);
     }
+    if (type === "content_type") {
+	if (!/html/.test(data))
+	    content_type_cell.classList.remove("hide");
+    }
     if (type === "repo_query_action") {
 	const key = data.prefix + data.item;
 	const results = queried_items.get(key) || {};
-- 
cgit v1.2.3


From 51d43685c667567516cfbda8dfeb75e98c00619f Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Sat, 4 Sep 2021 21:03:03 +0200
Subject: fix script blocking bug under Chromium

---
 content/main.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'content/main.js')

diff --git a/content/main.js b/content/main.js
index 4fe6d43..b2cc9ed 100644
--- a/content/main.js
+++ b/content/main.js
@@ -180,6 +180,26 @@ function sanitize_meta(meta, policy)
 	meta.content = sanitize_csp_header({value}, policy).value;
 }
 
+function sanitize_script(script)
+{
+    script.hachette_blocked_type = script.type;
+    script.type = "text/plain";
+}
+
+/*
+ * Executed after script has been connected to the DOM, when it is no longer
+ * eligible for being executed by the browser
+ */
+function desanitize_script(script, policy)
+{
+    script.setAttribute("type", script.hachette_blocked_type);
+
+    if (script.hachette_blocked_type === undefined)
+	script.removeAttribute("type");
+
+    delete script.hachette_blocked_type;
+}
+
 function apply_hachette_csp_rules(doc, policy)
 {
     const meta = doc.createElement("meta");
@@ -220,7 +240,13 @@ async function sanitize_document(doc, policy)
     for (const meta of old_html.querySelectorAll("head meta"))
 	sanitize_meta(meta, policy);
 
+    for (const script of old_html.querySelectorAll("script"))
+	sanitize_script(script, policy);
+
     new_html.replaceWith(old_html);
+
+    for (const script of old_html.querySelectorAll("script"))
+	desanitize_script(script, policy);
 }
 
 if (!is_privileged_url(document.URL)) {
-- 
cgit v1.2.3


From 704f2da0673dc714f72b9bb82f6bf648795d4335 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Mon, 6 Sep 2021 20:45:50 +0200
Subject: re-enable sanitizing of data: URLs and also sanitize intrinsics on
 non-HTML pages where CSP doesn't work

---
 content/freezer.js | 64 --------------------------------------------
 content/main.js    | 78 +++++++++++++++++++++++++++++++++++++++++++++---------
 copyright          |  5 ----
 3 files changed, 65 insertions(+), 82 deletions(-)
 delete mode 100644 content/freezer.js

(limited to 'content/main.js')

diff --git a/content/freezer.js b/content/freezer.js
deleted file mode 100644
index 0ea362e..0000000
--- a/content/freezer.js
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * Helper functions for blocking scripts in pages, based off NoScript's lib/DocumentFreezer.js
- *
- * Copyright (C) 2005-2021 Giorgio Maone - https://maone.net
- * Copyright (C) 2021 jahoti
- * Redistribution terms are gathered in the `copyright' file.
- */
-
-const loaderAttributes = ["href", "src", "data"];
-const jsOrDataUrlRx = /^(?:data:(?:[^,;]*ml|unknown-content-type)|javascript:)/i;
-
-function sanitize_attributes(element) {
-    if (element._frozen)
-	return;
-    let fa = [];
-    let loaders = [];
-    let attributes = element.attributes || [];
-
-    for (let a of attributes) {
-	let name = a.localName.toLowerCase();
-	if (loaderAttributes.includes(name))
-	    if (jsOrDataUrlRx.test(a.value))
-		loaders.push(a);
-
-	else if (name.startsWith("on")) {
-	    console.debug("Removing", a, element.outerHTML);
-	    fa.push(a.cloneNode());
-	    a.value = "";
-	    element[name] = null;
-	}
-    }
-    if (loaders.length) {
-	for (let a of loaders) {
-	    fa.push(a.cloneNode());
-	    a.value = "javascript://frozen";
-	}
-	if ("contentWindow" in element)
-	    element.replaceWith(element = element.cloneNode(true));
-
-    }
-    if (fa.length)
-	element._frozenAttributes = fa;
-    element._frozen = true;
-}
-
-function mozilla_suppress_scripts(e) {
-    if (document.readyState === 'complete') {
-	removeEventListener('beforescriptexecute', blockExecute, true);
-	console.log('Script suppressor has detached.');
-	return;
-    }
-    console.log("script event", e);
-    if (e.isTrusted && !e.target._hachette_payload) {
-	e.preventDefault();
-	console.log('Suppressed script', e.target);
-    }
-};
-
-/*
- * EXPORTS_START
- * EXPORT mozilla_suppress_scripts
- * EXPORT sanitize_attributes
- * EXPORTS_END
- */
diff --git a/content/main.js b/content/main.js
index b2cc9ed..a183913 100644
--- a/content/main.js
+++ b/content/main.js
@@ -13,7 +13,6 @@
  * IMPORT sign_data
  * IMPORT gen_nonce
  * IMPORT is_privileged_url
- * IMPORT mozilla_suppress_scripts
  * IMPORT is_chrome
  * IMPORT is_mozilla
  * IMPORT start_activity_info_server
@@ -132,10 +131,18 @@ function finish_waiting(waiting)
 function _wait_for_head(doc, detached_html, callback)
 {
     const waiting = {doc, detached_html, callback, observers: []};
-    if (try_body_started(waiting))
-	return;
 
-    waiting.observers = [make_body_start_observer(detached_html, waiting)];
+    /*
+     * For XML and SVG documents, instead of waiting for `<head>', we wait
+     * for the entire document to finish loading.
+     */
+    if (doc instanceof HTMLDocument) {
+	if (try_body_started(waiting))
+	    return;
+
+	waiting.observers = [make_body_start_observer(detached_html, waiting)];
+    }
+
     waiting.loaded_cb = () => finish_waiting(waiting);
     doc.addEventListener("DOMContentLoaded", waiting.loaded_cb);
 }
@@ -200,32 +207,72 @@ function desanitize_script(script, policy)
     delete script.hachette_blocked_type;
 }
 
-function apply_hachette_csp_rules(doc, policy)
+function apply_hachette_csp_rules(doc, head, policy)
 {
     const meta = doc.createElement("meta");
     meta.setAttribute("http-equiv", "Content-Security-Policy");
     meta.setAttribute("content", csp_rule(policy.nonce));
-    doc.head.append(meta);
+    head.append(meta);
     /* CSP is already in effect, we can remove the <meta> now. */
     meta.remove();
 }
 
+function sanitize_urls(element)
+{
+    for (const attribute of [...element.attributes]) {
+	if (/^(href|src|data)$/i.test(attribute.localName) &&
+	    /^data:([^,;]*ml|unknown-content-type)/i.test(attribute.value))
+	    block_attribute(element, attribute.localName);
+    }
+}
+
+function start_data_urls_sanitizing(doc)
+{
+    doc.querySelectorAll("*[href], *[src], *[data]").forEach(sanitize_urls);
+    const mutation_handler = m => m.addedNodes.forEach(sanitize_urls);
+    const mo = new MutationObserver(ms => ms.forEach(mutation_handler));
+    mo.observe(doc, {childList: true, subtree: true});
+}
+
+function apply_intrinsics_sanitizing(root_element)
+{
+    for (const subelem of root_element.querySelectorAll("*")) {
+	[...subelem.attributes]
+	    .filter(a => /^on/i.test(a.localName))
+	    .filter(a => /^javascript:/i.test(a.value))
+	    .forEach(a => block_attribute(subelem, a.localName));
+    }
+}
+
 async function sanitize_document(doc, policy)
 {
+    /*
+     * Blocking of scripts that are in the DOM from the beginning. Needed for
+     * Mozilla, harmless on Chromium.
+     * Note that at least in SVG documents the `src' attr on `<script>'s seems
+     * to be ignored by Firefox, so we don't need to sanitize it.
+     */
+    for (const script of document.getElementsByTagName("script")) {
+	const old_children = [...script.childNodes];
+	script.innerHTML = "";
+	setTimeout(() => old_children.forEach(c => script.append(c)), 0);
+    }
+
     /*
      * Ensure our CSP rules are employed from the beginning. This CSP injection
      * method is, when possible, going to be applied together with CSP rules
      * injected using webRequest.
+     * For non-HTML documents this is just a dummy operation of adding and
+     * removing `head'.
      */
-    const has_own_head = doc.head;
-    if (!has_own_head)
-	doc.documentElement.prepend(doc.createElement("head"));
+    let added_head = doc.createElement("head");
+    if (!doc.head)
+	doc.documentElement.prepend(added_head);
 
-    apply_hachette_csp_rules(doc, policy);
+    apply_hachette_csp_rules(doc, added_head, policy);
 
-    /* Probably not needed, but...: proceed with DOM in its initial state. */
-    if (!has_own_head)
-	doc.head.remove();
+    /* Proceed with DOM in its initial state. */
+    added_head.remove();
 
     /*
      * <html> node gets hijacked now, to be re-attached after <head> is loaded
@@ -243,10 +290,15 @@ async function sanitize_document(doc, policy)
     for (const script of old_html.querySelectorAll("script"))
 	sanitize_script(script, policy);
 
+    if (!(doc instanceof HTMLDocument))
+	apply_intrinsics_sanitizing(old_html);
+
     new_html.replaceWith(old_html);
 
     for (const script of old_html.querySelectorAll("script"))
 	desanitize_script(script, policy);
+
+    start_data_urls_sanitizing(doc);
 }
 
 if (!is_privileged_url(document.URL)) {
diff --git a/copyright b/copyright
index 58993a6..4c37eb3 100644
--- a/copyright
+++ b/copyright
@@ -67,11 +67,6 @@ License: Expat
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-Files: content/freezer.js
-Copyright: 2005-2021 Giorgio Maone - https://maone.net
-   2021 jahoti <jahoti@tilde.team>
-License: GPL-2+
-
 Files: licenses/*
 Copyright: 2001, 2002, 2011-2013 Creative Commons
 License: CC-BY-4.0
-- 
cgit v1.2.3


From e2d26bad35bbe3876862b482f7963d713238313b Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Wed, 8 Sep 2021 19:55:33 +0200
Subject: Fix sanitizing of non-HTML XMLDocument's

---
 build.sh                        |   4 +-
 common/misc.js                  |   4 +-
 content/activity_info_server.js |   6 +-
 content/main.js                 | 195 ++++++++++++++++++++--------------------
 content/page_actions.js         |   6 +-
 html/display-panel.js           |   4 +-
 6 files changed, 109 insertions(+), 110 deletions(-)

(limited to 'content/main.js')

diff --git a/build.sh b/build.sh
index 66f709c..478ca04 100755
--- a/build.sh
+++ b/build.sh
@@ -201,9 +201,7 @@ main() {
 
     if [ "$BROWSER" = "chromium" ]; then
 	CHROMIUM_KEY="$(dd if=/dev/urandom bs=32 count=1 2>/dev/null | base64)"
-	echo "chromium key is" $CHROMIUM_KEY
-	CHROMIUM_KEY="chromium-key-dummy-file-$CHROMIUM_KEY"
-	CHROMIUM_KEY=$(echo $CHROMIUM_KEY | tr / -);
+	CHROMIUM_KEY=$(echo chromium-key-dummy-file-$CHROMIUM_KEY | tr / -)
 	touch $BUILDDIR/$CHROMIUM_KEY
 
 	CHROMIUM_KEY="\n\
diff --git a/common/misc.js b/common/misc.js
index 91d60d2..6adaf1e 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -36,9 +36,9 @@ function Uint8toHex(data)
     return returnValue;
 }
 
-function gen_nonce(length) // Default 16
+function gen_nonce(length=16)
 {
-    let randomData = new Uint8Array(length || 16);
+    let randomData = new Uint8Array(length);
     crypto.getRandomValues(randomData);
     return Uint8toHex(randomData);
 }
diff --git a/content/activity_info_server.js b/content/activity_info_server.js
index beecb1a..1b69703 100644
--- a/content/activity_info_server.js
+++ b/content/activity_info_server.js
@@ -44,9 +44,9 @@ function report_settings(settings)
     report_activity("settings", settings);
 }
 
-function report_content_type(content_type)
+function report_document_type(is_html)
 {
-    report_activity("content_type", content_type);
+    report_activity("is_html", is_html);
 }
 
 function report_repo_query_action(update, port)
@@ -96,6 +96,6 @@ function start_activity_info_server()
  * EXPORT start_activity_info_server
  * EXPORT report_script
  * EXPORT report_settings
- * EXPORT report_content_type
+ * EXPORT report_document_type
  * EXPORTS_END
  */
diff --git a/content/main.js b/content/main.js
index a183913..fb334dd 100644
--- a/content/main.js
+++ b/content/main.js
@@ -22,6 +22,12 @@
  * IMPORTS_END
  */
 
+document.content_loaded = document.readyState === "complete";
+const wait_loaded = e => e.content_loaded ? Promise.resolve() :
+      new Promise(c => e.addEventListener("DOMContentLoaded", c, {once: true}));
+
+wait_loaded(document).then(() => document.content_loaded = true);
+
 function extract_cookie_policy(cookie, min_time)
 {
     let best_result = {time: -1};
@@ -86,18 +92,17 @@ function employ_nonhttp_policy(policy)
 }
 
 /*
+ * In the case of HTML documents:
  * 1. When injecting some payload we need to sanitize <meta> CSP tags before
  *    they reach the document.
  * 2. Only <meta> tags inside <head> are considered valid by the browser and
  *    need to be considered.
  * 3. We want to detach <html> from document, wait until its <head> completes
  *    loading, sanitize it and re-attach <html>.
- * 4. Browsers are eager to add <meta>'s that appear after `</head>' but before
- *    `<body>'. Due to this behavior the `DOMContentLoaded' event is considered
- *    unreliable (although it could still work properly, it is just problematic
- *    to verify).
- * 5. We shall wait for anything to appear in or after <body> and take that as
- *    a sign <head> has _really_ finished loading.
+ * 4. We shall wait for anything to appear in or after <body> and take that as
+ *    a sign <head> has finished loading.
+ * 5. Otherwise, getting the `DOMContentLoaded' event on the document shall also
+ *    be a sign that <head> is fully loaded.
  */
 
 function make_body_start_observer(DOM_element, waiting)
@@ -123,8 +128,10 @@ function try_body_started(waiting)
 
 function finish_waiting(waiting)
 {
+    if (waiting.finished)
+	return;
+    waiting.finished = true;
     waiting.observers.forEach(observer => observer.disconnect());
-    waiting.doc.removeEventListener("DOMContentLoaded", waiting.loaded_cb);
     setTimeout(waiting.callback, 0);
 }
 
@@ -132,19 +139,12 @@ function _wait_for_head(doc, detached_html, callback)
 {
     const waiting = {doc, detached_html, callback, observers: []};
 
-    /*
-     * For XML and SVG documents, instead of waiting for `<head>', we wait
-     * for the entire document to finish loading.
-     */
-    if (doc instanceof HTMLDocument) {
-	if (try_body_started(waiting))
-	    return;
+    if (try_body_started(waiting))
+	return;
 
-	waiting.observers = [make_body_start_observer(detached_html, waiting)];
-    }
+    waiting.observers = [make_body_start_observer(detached_html, waiting)];
 
-    waiting.loaded_cb = () => finish_waiting(waiting);
-    doc.addEventListener("DOMContentLoaded", waiting.loaded_cb);
+    wait_loaded(doc).then(() => finish_waiting(waiting));
 }
 
 function wait_for_head(doc, detached_html)
@@ -154,42 +154,43 @@ function wait_for_head(doc, detached_html)
 
 const blocked_str = "blocked";
 
-function block_attribute(node, attr)
+function block_attribute(node, attr, ns=null)
 {
+    const [hasa, geta, seta, rema] = ["has", "get", "set", "remove"]
+	  .map(m => (n, ...args) => typeof ns === "string" ?
+	       n[`${m}AttributeNS`](ns, ...args) : n[`${m}Attribute`](...args));
     /*
-     * Disabling attributes this way allows them to still be relatively
-     * easily accessed in case they contain some useful data.
+     * Disabling attributes by prepending `-blocked' allows them to still be
+     * relatively easily accessed in case they contain some useful data.
      */
     const construct_name = [attr];
-    while (node.hasAttribute(construct_name.join("")))
+    while (hasa(node, construct_name.join("")))
 	construct_name.unshift(blocked_str);
 
     while (construct_name.length > 1) {
 	construct_name.shift();
 	const name = construct_name.join("");
-	node.setAttribute(`${blocked_str}-${name}`, node.getAttribute(name));
+	seta(node, `${blocked_str}-${name}`, geta(node, name));
     }
-
-    node.removeAttribute(attr);
 }
 
 function sanitize_meta(meta, policy)
 {
-    const http_equiv = meta.getAttribute("http-equiv");
-    const value = meta.content;
+    const value = meta.content || "";
 
-    if (!value || !is_csp_header_name(http_equiv, true))
+    if (!value || !is_csp_header_name(meta.httpEquiv || "", true))
 	return;
 
     block_attribute(meta, "content");
-
-    if (is_csp_header_name(http_equiv, false))
-	meta.content = sanitize_csp_header({value}, policy).value;
 }
 
+/*
+ * Used to disable <script> that has not yet been added to live DOM (doesn't
+ * work for those already added).
+ */
 function sanitize_script(script)
 {
-    script.hachette_blocked_type = script.type;
+    script.hachette_blocked_type = script.getAttribute("type");
     script.type = "text/plain";
 }
 
@@ -201,102 +202,101 @@ function desanitize_script(script, policy)
 {
     script.setAttribute("type", script.hachette_blocked_type);
 
-    if (script.hachette_blocked_type === undefined)
+    if (script.hachette_blocked_type === null)
 	script.removeAttribute("type");
 
     delete script.hachette_blocked_type;
 }
 
-function apply_hachette_csp_rules(doc, head, policy)
-{
-    const meta = doc.createElement("meta");
-    meta.setAttribute("http-equiv", "Content-Security-Policy");
-    meta.setAttribute("content", csp_rule(policy.nonce));
-    head.append(meta);
-    /* CSP is already in effect, we can remove the <meta> now. */
-    meta.remove();
-}
-
+const bad_url_reg = /^data:([^,;]*ml|unknown-content-type)/i;
 function sanitize_urls(element)
 {
-    for (const attribute of [...element.attributes]) {
-	if (/^(href|src|data)$/i.test(attribute.localName) &&
-	    /^data:([^,;]*ml|unknown-content-type)/i.test(attribute.value))
-	    block_attribute(element, attribute.localName);
-    }
+    for (const attr of [...element.attributes || []]
+	       .filter(attr => /^(href|src|data)$/i.test(attr.localName))
+	       .filter(attr => bad_url_reg.test(attr.value)))
+	block_attribute(element, attr.localName, attr.namespaceURI);
 }
 
 function start_data_urls_sanitizing(doc)
 {
     doc.querySelectorAll("*[href], *[src], *[data]").forEach(sanitize_urls);
-    const mutation_handler = m => m.addedNodes.forEach(sanitize_urls);
-    const mo = new MutationObserver(ms => ms.forEach(mutation_handler));
-    mo.observe(doc, {childList: true, subtree: true});
+    if (!doc.content_loaded) {
+	const mutation_handler = m => m.addedNodes.forEach(sanitize_urls);
+	const mo = new MutationObserver(ms => ms.forEach(mutation_handler));
+	mo.observe(doc, {childList: true, subtree: true});
+	wait_loaded(doc).then(() => mo.disconnect());
+    }
 }
 
-function apply_intrinsics_sanitizing(root_element)
+/*
+ * Normally, we block scripts with CSP. However, Mozilla does optimizations that
+ * cause part of the DOM to be loaded when our content scripts get to run. Thus,
+ * before the CSP rules we inject (for non-HTTP pages) become effective, we need
+ * to somehow block the execution of `<script>'s and intrinsics that were
+ * already there.
+ */
+function mozilla_initial_block(doc)
 {
-    for (const subelem of root_element.querySelectorAll("*")) {
-	[...subelem.attributes]
-	    .filter(a => /^on/i.test(a.localName))
-	    .filter(a => /^javascript:/i.test(a.value))
-	    .forEach(a => block_attribute(subelem, a.localName));
-    }
+    const blocker = e => e.preventDefault();
+    doc.addEventListener("beforescriptexecute", blocker);
+    setTimeout(() => doc.removeEventListener("beforescriptexecute", blocker));
+
+    [...doc.all].flatMap(ele => [...ele.attributes].map(attr => [ele, attr]))
+	.map(([ele, attr]) => [ele, attr.localName])
+	.filter(([ele, attr]) => /^on/.test(attr) && ele.wrappedJSObject[attr])
+	.forEach(([ele, attr]) => ele.wrappedJSObject[attr] = null);
 }
 
+/*
+ * Here we block all scripts of a document which might be either and
+ * HTMLDocument or an XMLDocument. Modifying an XML document might disrupt
+ * Mozilla's XML preview. This is an unfortunate thing we have to accept for
+ * now. XML documents *have to* be sanitized as well because they might
+ * contain `<script>' tags (or on* attributes) with namespace declared as
+ * "http://www.w3.org/1999/xhtml" or "http://www.w3.org/2000/svg" which allows
+ * javascript execution.
+ */
 async function sanitize_document(doc, policy)
 {
     /*
      * Blocking of scripts that are in the DOM from the beginning. Needed for
-     * Mozilla, harmless on Chromium.
-     * Note that at least in SVG documents the `src' attr on `<script>'s seems
-     * to be ignored by Firefox, so we don't need to sanitize it.
+     * Mozilla.
      */
-    for (const script of document.getElementsByTagName("script")) {
-	const old_children = [...script.childNodes];
-	script.innerHTML = "";
-	setTimeout(() => old_children.forEach(c => script.append(c)), 0);
-    }
+    if (is_mozilla)
+	mozilla_initial_block(doc);
 
     /*
      * Ensure our CSP rules are employed from the beginning. This CSP injection
      * method is, when possible, going to be applied together with CSP rules
      * injected using webRequest.
-     * For non-HTML documents this is just a dummy operation of adding and
-     * removing `head'.
+     * Using elements namespaced as HTML makes this CSP injection also work for
+     * non-HTML documents.
      */
-    let added_head = doc.createElement("head");
-    if (!doc.head)
-	doc.documentElement.prepend(added_head);
-
-    apply_hachette_csp_rules(doc, added_head, policy);
-
-    /* Proceed with DOM in its initial state. */
-    added_head.remove();
+    const html = new DOMParser().parseFromString(`<html><head><meta \
+http-equiv="Content-Security-Policy" content="${csp_rule(policy.nonce)}"\
+/></head><body>Loading...</body></html>`, "text/html").documentElement;
 
     /*
-     * <html> node gets hijacked now, to be re-attached after <head> is loaded
+     * Root node gets hijacked now, to be re-attached after <head> is loaded
      * and sanitized.
      */
-    const old_html = doc.documentElement;
-    const new_html = doc.createElement("html");
-    old_html.replaceWith(new_html);
+    const root = doc.documentElement;
+    root.replaceWith(html);
 
-    await wait_for_head(doc, old_html);
-
-    for (const meta of old_html.querySelectorAll("head meta"))
-	sanitize_meta(meta, policy);
-
-    for (const script of old_html.querySelectorAll("script"))
-	sanitize_script(script, policy);
-
-    if (!(doc instanceof HTMLDocument))
-	apply_intrinsics_sanitizing(old_html);
+    /*
+     * For XML documents, we don't intend to inject payload, so we neither block
+     * document's CSP `<meta>' tags nor wait for `<head>' to be parsed.
+     */
+    if (document instanceof HTMLDocument) {
+	await wait_for_head(doc, root);
 
-    new_html.replaceWith(old_html);
+	root.querySelectorAll("head meta")
+	    .forEach(m => sanitize_meta(m, policy));
+    }
 
-    for (const script of old_html.querySelectorAll("script"))
-	desanitize_script(script, policy);
+    root.querySelectorAll("script").forEach(s => sanitize_script(s, policy));
+    html.replaceWith(root);
+    root.querySelectorAll("script").forEach(s => desanitize_script(s, policy));
 
     start_data_urls_sanitizing(doc);
 }
@@ -329,14 +329,15 @@ if (!is_privileged_url(document.URL)) {
     }
 
     if (!policy) {
-	console.warn("Using fallback policy!");
+	console.debug("Using fallback policy!");
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
+    console.debug("current policy", policy);
+
     const doc_ready = Promise.all([
-	policy.allow ? Promise.resolve : sanitize_document(document, policy),
-	new Promise(cb => document.addEventListener("DOMContentLoaded",
-						    cb, {once: true}))
+	policy.allow ? Promise.resolve() : sanitize_document(document, policy),
+	wait_loaded(document)
     ]);
 
     handle_page_actions(policy.nonce, policy_received_callback, doc_ready);
diff --git a/content/page_actions.js b/content/page_actions.js
index 8057541..040b4ab 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -11,7 +11,7 @@
  * IMPORT browser
  * IMPORT report_script
  * IMPORT report_settings
- * IMPORT report_content_type
+ * IMPORT report_document_type
  * IMPORTS_END
  */
 
@@ -70,8 +70,8 @@ function handle_page_actions(script_nonce, policy_received_cb,
 			     doc_ready_promise) {
     policy_received_callback = policy_received_cb;
     url = document.URL;
-    is_html = /html/.test(document.contentType);
-    report_content_type(document.contentType);
+    is_html = document instanceof HTMLDocument;
+    report_document_type(is_html);
 
     doc_ready_promise.then(document_ready);
 
diff --git a/html/display-panel.js b/html/display-panel.js
index 7d801c9..623ff36 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -276,8 +276,8 @@ function handle_activity_report(message)
 	template.script_contents.textContent = data;
 	container_for_injected.appendChild(template.div);
     }
-    if (type === "content_type") {
-	if (!/html/.test(data))
+    if (type === "is_html") {
+	if (!data)
 	    content_type_cell.classList.remove("hide");
     }
     if (type === "repo_query_action") {
-- 
cgit v1.2.3


From 44e89d8ec71b441a431c848567f34b9a36f6b982 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Thu, 9 Sep 2021 17:47:51 +0200
Subject: simplify CSP handling

All page's CSP rules are now removed when a payload is to be injected. When there is no payload, CSP rules are not modified but only supplemented with Hachette's own.
---
 background/policy_injector.js | 30 ++++++++++---------
 background/stream_filter.js   |  5 ++--
 common/misc.js                | 68 +++++++------------------------------------
 content/main.js               | 57 +++++++++++++++++++-----------------
 4 files changed, 60 insertions(+), 100 deletions(-)

(limited to 'content/main.js')

diff --git a/background/policy_injector.js b/background/policy_injector.js
index 72318d4..e5af055 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -10,9 +10,8 @@
  * IMPORTS_START
  * IMPORT sign_data
  * IMPORT extract_signed
- * IMPORT sanitize_csp_header
- * IMPORT csp_rule
- * IMPORT is_csp_header_name
+ * IMPORT make_csp_rule
+ * IMPORT csp_header_regex
  * IMPORTS_END
  */
 
@@ -43,22 +42,25 @@ function inject_csp_headers(headers, policy)
 	break;
     }
 
+    if (policy.has_payload) {
+	csp_headers = [];
+	const non_csp_headers = [];
+	const header_list =
+	      h => csp_header_regex.test(h) ? csp_headers : non_csp_headers;
+	headers.forEach(h => header_list(h.name).push(h));
+	headers = non_csp_headers;
+    } else {
+	headers.push(...csp_headers || []);
+    }
+
     if (!hachette_header) {
 	hachette_header = {name: "x-hachette"};
 	headers.push(hachette_header);
     }
 
-    csp_headers = csp_headers ||
-	headers.filter(h => is_csp_header_name(h.name));
-
-    /* When blocking remove report-only CSP headers that snitch on us. */
-    headers = headers.filter(h => !is_csp_header_name(h.name, !policy.allow));
-
     if (old_signature)
 	headers = headers.filter(h => h.value.search(old_signature) === -1);
 
-    headers.push(...csp_headers.map(h => sanitize_csp_header(h, policy)));
-
     const policy_str = encodeURIComponent(JSON.stringify(policy));
     const signed_policy = sign_data(policy_str, new Date().getTime());
     const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
@@ -76,12 +78,12 @@ function inject_csp_headers(headers, policy)
     hachette_data = encodeURIComponent(JSON.stringify(hachette_data));
     hachette_header.value = sign_data(hachette_data, 0).join("_");
 
-    /* To ensure there is a CSP header if required */
-    if (!policy.allow)
+    if (!policy.allow) {
 	headers.push({
 	    name: "content-security-policy",
-	    value: csp_rule(policy.nonce)
+	    value: make_csp_rule(policy)
 	});
+    }
 
     return headers;
 }
diff --git a/background/stream_filter.js b/background/stream_filter.js
index 96b6132..3e30a4b 100644
--- a/background/stream_filter.js
+++ b/background/stream_filter.js
@@ -12,7 +12,7 @@
 /*
  * IMPORTS_START
  * IMPORT browser
- * IMPORT is_csp_header_name
+ * IMPORT csp_header_regex
  * IMPORTS_END
  */
 
@@ -116,8 +116,7 @@ function may_define_csp_rules(html)
     const doc = new DOMParser().parseFromString(html, "text/html");
 
     for (const meta of doc.querySelectorAll("head>meta[http-equiv]")) {
-	if (is_csp_header_name(meta.getAttribute("http-equiv"), true) &&
-	    meta.content)
+	if (csp_header_regex.test(meta.httpEquiv) && meta.content)
 	    return true;
     }
 
diff --git a/common/misc.js b/common/misc.js
index 6adaf1e..6cded84 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -43,29 +43,19 @@ function gen_nonce(length=16)
     return Uint8toHex(randomData);
 }
 
-/* csp rule that blocks all scripts except for those injected by us */
-function csp_rule(nonce)
+/* CSP rule that blocks scripts according to policy's needs. */
+function make_csp_rule(policy)
 {
-    const rule = `'nonce-${nonce}'`;
-    return `script-src ${rule}; script-src-elem ${rule}; script-src-attr 'none'; prefetch-src 'none';`;
+    let rule = "prefetch-src 'none'; script-src-attr 'none';";
+    const script_src = policy.has_payload ?
+	  `'nonce-${policy.nonce}'` : "'none'";
+    rule += ` script-src ${script_src}; script-src-elem ${script_src};`;
+    return rule;
 }
 
 /* Check if some HTTP header might define CSP rules. */
-const csp_header_names = new Set([
-    "content-security-policy",
-    "x-webkit-csp",
-    "x-content-security-policy"
-]);
-
-const report_only_header_name = "content-security-policy-report-only";
-
-function is_csp_header_name(string, include_report_only)
-{
-    string = string && string.toLowerCase().trim() || "";
-
-    return (include_report_only && string === report_only_header_name) ||
-	csp_header_names.has(string);
-}
+const csp_header_regex =
+      /^\s*(content-security-policy|x-webkit-csp|x-content-security-policy)/i;
 
 /*
  * Print item together with type, e.g.
@@ -111,41 +101,6 @@ function parse_csp(csp) {
     return directives;
 }
 
-/* Make CSP headers do our bidding, not interfere */
-function sanitize_csp_header(header, policy)
-{
-    const rule = `'nonce-${policy.nonce}'`;
-    const csp = parse_csp(header.value);
-
-    if (!policy.allow) {
-	/* No snitching */
-	delete csp['report-to'];
-	delete csp['report-uri'];
-
-	delete csp['script-src'];
-	delete csp['script-src-elem'];
-
-	csp['script-src-attr'] = ["'none'"];
-	csp['prefetch-src'] = ["'none'"];
-    }
-
-    if ('script-src' in csp)
-	csp['script-src'].push(rule);
-    else
-	csp['script-src'] = [rule];
-
-    if ('script-src-elem' in csp)
-	csp['script-src-elem'].push(rule);
-    else
-	csp['script-src-elem'] = [rule];
-
-    const new_csp = Object.entries(csp).map(
-	i => `${i[0]} ${i[1].join(' ')};`
-    );
-
-    return {name: header.name, value: new_csp.join('')};
-}
-
 /* Regexes and objects to use as/in schemas for parse_json_with_schema(). */
 const nonempty_string_matcher = /.+/;
 
@@ -161,12 +116,11 @@ const matchers = {
 /*
  * EXPORTS_START
  * EXPORT gen_nonce
- * EXPORT csp_rule
- * EXPORT is_csp_header_name
+ * EXPORT make_csp_rule
+ * EXPORT csp_header_regex
  * EXPORT nice_name
  * EXPORT open_in_settings
  * EXPORT is_privileged_url
- * EXPORT sanitize_csp_header
  * EXPORT matchers
  * EXPORTS_END
  */
diff --git a/content/main.js b/content/main.js
index fb334dd..a26f72d 100644
--- a/content/main.js
+++ b/content/main.js
@@ -16,9 +16,8 @@
  * IMPORT is_chrome
  * IMPORT is_mozilla
  * IMPORT start_activity_info_server
- * IMPORT csp_rule
- * IMPORT is_csp_header_name
- * IMPORT sanitize_csp_header
+ * IMPORT make_csp_rule
+ * IMPORT csp_header_regex
  * IMPORTS_END
  */
 
@@ -172,22 +171,20 @@ function block_attribute(node, attr, ns=null)
 	const name = construct_name.join("");
 	seta(node, `${blocked_str}-${name}`, geta(node, name));
     }
-}
-
-function sanitize_meta(meta, policy)
-{
-    const value = meta.content || "";
 
-    if (!value || !is_csp_header_name(meta.httpEquiv || "", true))
-	return;
-
-    block_attribute(meta, "content");
+    rema(node, attr);
 }
 
 /*
- * Used to disable <script> that has not yet been added to live DOM (doesn't
- * work for those already added).
+ * Used to disable `<script>'s and `<meta>'s that have not yet been added to
+ * live DOM (doesn't work for those already added).
  */
+function sanitize_meta(meta)
+{
+    if (csp_header_regex.test(meta.httpEquiv) && meta.content)
+	block_attribute(meta, "content");
+}
+
 function sanitize_script(script)
 {
     script.hachette_blocked_type = script.getAttribute("type");
@@ -195,14 +192,14 @@ function sanitize_script(script)
 }
 
 /*
- * Executed after script has been connected to the DOM, when it is no longer
- * eligible for being executed by the browser
+ * Executed after `<script>' has been connected to the DOM, when it is no longer
+ * eligible for being executed by the browser.
  */
-function desanitize_script(script, policy)
+function desanitize_script(script)
 {
     script.setAttribute("type", script.hachette_blocked_type);
 
-    if (script.hachette_blocked_type === null)
+    if ([null, undefined].includes(script.hachette_blocked_type))
 	script.removeAttribute("type");
 
     delete script.hachette_blocked_type;
@@ -233,13 +230,18 @@ function start_data_urls_sanitizing(doc)
  * cause part of the DOM to be loaded when our content scripts get to run. Thus,
  * before the CSP rules we inject (for non-HTTP pages) become effective, we need
  * to somehow block the execution of `<script>'s and intrinsics that were
- * already there.
+ * already there. Additionally, some browsers (IceCat 60) seem to have problems
+ * applying this CSP to non-inline `<scripts>' in certain scenarios.
  */
+function prevent_script_execution(event)
+{
+    if (!event.target._hachette_payload)
+	event.preventDefault();
+}
+
 function mozilla_initial_block(doc)
 {
-    const blocker = e => e.preventDefault();
-    doc.addEventListener("beforescriptexecute", blocker);
-    setTimeout(() => doc.removeEventListener("beforescriptexecute", blocker));
+    doc.addEventListener("beforescriptexecute", prevent_script_execution);
 
     [...doc.all].flatMap(ele => [...ele.attributes].map(attr => [ele, attr]))
 	.map(([ele, attr]) => [ele, attr.localName])
@@ -273,7 +275,7 @@ async function sanitize_document(doc, policy)
      * non-HTML documents.
      */
     const html = new DOMParser().parseFromString(`<html><head><meta \
-http-equiv="Content-Security-Policy" content="${csp_rule(policy.nonce)}"\
+http-equiv="Content-Security-Policy" content="${make_csp_rule(policy)}"\
 /></head><body>Loading...</body></html>`, "text/html").documentElement;
 
     /*
@@ -284,10 +286,10 @@ http-equiv="Content-Security-Policy" content="${csp_rule(policy.nonce)}"\
     root.replaceWith(html);
 
     /*
-     * For XML documents, we don't intend to inject payload, so we neither block
-     * document's CSP `<meta>' tags nor wait for `<head>' to be parsed.
+     * When we don't inject payload, we neither block document's CSP `<meta>'
+     * tags nor wait for `<head>' to be parsed.
      */
-    if (document instanceof HTMLDocument) {
+    if (policy.has_payload) {
 	await wait_for_head(doc, root);
 
 	root.querySelectorAll("head meta")
@@ -333,6 +335,9 @@ if (!is_privileged_url(document.URL)) {
 	policy = {allow: false, nonce: gen_nonce()};
     }
 
+    if (!(document instanceof HTMLDocument))
+	policy.has_payload = false;
+
     console.debug("current policy", policy);
 
     const doc_ready = Promise.all([
-- 
cgit v1.2.3


From ed9cc030ec7992b3f59d155067a3ebff6c9e1faa Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Thu, 9 Sep 2021 18:51:38 +0200
Subject: restore compatibility with IceCat 60

---
 content/main.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'content/main.js')

diff --git a/content/main.js b/content/main.js
index a26f72d..cc7692a 100644
--- a/content/main.js
+++ b/content/main.js
@@ -243,10 +243,11 @@ function mozilla_initial_block(doc)
 {
     doc.addEventListener("beforescriptexecute", prevent_script_execution);
 
-    [...doc.all].flatMap(ele => [...ele.attributes].map(attr => [ele, attr]))
-	.map(([ele, attr]) => [ele, attr.localName])
-	.filter(([ele, attr]) => /^on/.test(attr) && ele.wrappedJSObject[attr])
-	.forEach(([ele, attr]) => ele.wrappedJSObject[attr] = null);
+    for (const elem of doc.querySelectorAll("*")) {
+	[...elem.attributes].map(attr => attr.localName)
+	    .filter(attr => /^on/.test(attr) && elem.wrappedJSObject[attr])
+	    .forEach(attr => elem.wrappedJSObject[attr] = null);
+    }
 }
 
 /*
-- 
cgit v1.2.3


From d658cadf5184b127ec6ae6d6d8900f5e428095b0 Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Fri, 10 Sep 2021 17:46:24 +0200
Subject: disable service workers when scripts are blocked

---
 content/main.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'content/main.js')

diff --git a/content/main.js b/content/main.js
index cc7692a..6478ea0 100644
--- a/content/main.js
+++ b/content/main.js
@@ -304,6 +304,27 @@ http-equiv="Content-Security-Policy" content="${make_csp_rule(policy)}"\
     start_data_urls_sanitizing(doc);
 }
 
+async function disable_service_workers()
+{
+    if (!navigator.serviceWorker)
+	return;
+
+    const registrations = await navigator.serviceWorker.getRegistrations();
+    if (registrations.length === 0)
+	return;
+
+    console.warn("Service Workers detected on this page! Unregistering and reloading");
+
+    try {
+	await Promise.all(registrations.map(r => r.unregister()));
+    } finally {
+	location.reload();
+    }
+
+    /* Never actually return! */
+    return new Promise(() => 0);
+}
+
 if (!is_privileged_url(document.URL)) {
     let policy_received_callback = () => undefined;
     let policy;
@@ -343,6 +364,7 @@ if (!is_privileged_url(document.URL)) {
 
     const doc_ready = Promise.all([
 	policy.allow ? Promise.resolve() : sanitize_document(document, policy),
+	policy.allow ? Promise.resolve() : disable_service_workers(),
 	wait_loaded(document)
     ]);
 
-- 
cgit v1.2.3


From 2bd35bc4b0d32b70320b06d932db90e75e89373e Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Mon, 13 Sep 2021 16:56:44 +0200
Subject: rename the extension to "Haketilo"

---
 README.txt                        |   6 +-
 background/cookie_filter.js       |  17 ++---
 background/main.js                |   4 +-
 background/page_actions_server.js |   4 +-
 background/policy_injector.js     |  26 ++++----
 background/storage.js             |   4 +-
 background/storage_server.js      |   4 +-
 background/stream_filter.js       |   6 +-
 common/ajax.js                    |   5 +-
 common/connection_types.js        |   4 +-
 common/lock.js                    |   4 +-
 common/message_server.js          |   4 +-
 common/misc.js                    |   4 +-
 common/observable.js              |   5 +-
 common/once.js                    |   5 +-
 common/patterns.js                |   4 +-
 common/sanitize_JSON.js           |   5 +-
 common/settings_query.js          |   4 +-
 common/signing.js                 |   7 ++-
 common/storage_client.js          |   4 +-
 common/storage_light.js           |   5 +-
 common/storage_raw.js             |   5 +-
 common/stored_types.js            |   4 +-
 content/activity_info_server.js   |   7 ++-
 content/main.js                   |  22 ++++---
 content/page_actions.js           |   6 +-
 content/repo_query.js             |   5 +-
 copyright                         |   2 +-
 html/DOM_helpers.js               |   4 +-
 html/MOZILLA_scrollbar_fix.css    |   6 +-
 html/back_button.css              |   5 +-
 html/base.css                     |   4 +-
 html/default_blocking_policy.js   |   5 +-
 html/display-panel.html           |   8 ++-
 html/display-panel.js             |   4 +-
 html/import_frame.js              |   4 +-
 html/options.html                 |   6 +-
 html/options_main.js              |   4 +-
 icons/hachette.svg                | 127 --------------------------------------
 icons/hachette128.png             | Bin 6031 -> 0 bytes
 icons/hachette16.png              | Bin 752 -> 0 bytes
 icons/hachette32.png              | Bin 1358 -> 0 bytes
 icons/hachette48.png              | Bin 2154 -> 0 bytes
 icons/hachette64.png              | Bin 2908 -> 0 bytes
 icons/haketilo.svg                | 127 ++++++++++++++++++++++++++++++++++++++
 icons/haketilo128.png             | Bin 0 -> 6031 bytes
 icons/haketilo16.png              | Bin 0 -> 752 bytes
 icons/haketilo32.png              | Bin 0 -> 1358 bytes
 icons/haketilo48.png              | Bin 0 -> 2154 bytes
 icons/haketilo64.png              | Bin 0 -> 2908 bytes
 manifest.json                     |  28 +++++----
 re-generate_icons.sh              |   2 +-
 52 files changed, 292 insertions(+), 224 deletions(-)
 delete mode 100644 icons/hachette.svg
 delete mode 100644 icons/hachette128.png
 delete mode 100644 icons/hachette16.png
 delete mode 100644 icons/hachette32.png
 delete mode 100644 icons/hachette48.png
 delete mode 100644 icons/hachette64.png
 create mode 100644 icons/haketilo.svg
 create mode 100644 icons/haketilo128.png
 create mode 100644 icons/haketilo16.png
 create mode 100644 icons/haketilo32.png
 create mode 100644 icons/haketilo48.png
 create mode 100644 icons/haketilo64.png

(limited to 'content/main.js')

diff --git a/README.txt b/README.txt
index ad640b0..1aec0ba 100644
--- a/README.txt
+++ b/README.txt
@@ -1,4 +1,4 @@
-# Hachette - Make The Web Great Again! #
+# Haketilo - Make The Web Great Again! #
 
 This extension's goal is to allow replacing javascript served by websites
 with scripts specified by user. Something like NoScript and Greasemonkey
@@ -9,7 +9,7 @@ Currently, the target browsers for this extension are Ungoogled Chromium
 and various forks of Firefox (version 60+).
 
 This extension is still in an early stage. Also see
-`https://hachettebugs.koszko.org/projects/hachette/wiki/' for documentation in
+`https://hydrillabugs.koszko.org/projects/haketilo/wiki/' for documentation in
 development.
 
 ## Installation ##
@@ -28,6 +28,6 @@ various additional licenses and permissions for particular files.
 
 ## Contributing ##
 Get the code from: https://git.koszko.org/browser-extension/
-Come to: https://hachettebugs.koszko.org/projects/hachette
+Come to: https://hydrillabugs.koszko.org/projects/haketilo
 
 Optionally, write to $(echo a29zemtvQGtvc3prby5vcmcK | base64 -d)
diff --git a/background/cookie_filter.js b/background/cookie_filter.js
index fea2d23..64d18b2 100644
--- a/background/cookie_filter.js
+++ b/background/cookie_filter.js
@@ -1,7 +1,8 @@
 /**
- * part of Hachette
- * Filtering request headers to remove hachette cookies that might have slipped
- * through.
+ * This file is part of Haketilo.
+ *
+ * Function: Filtering request headers to remove haketilo cookies that might
+ *     have slipped through.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
@@ -13,29 +14,29 @@
  * IMPORTS_END
  */
 
-function is_valid_hachette_cookie(cookie)
+function is_valid_haketilo_cookie(cookie)
 {
-    const match = /^hachette-(\w*)=(.*)$/.exec(cookie);
+    const match = /^haketilo-(\w*)=(.*)$/.exec(cookie);
     if (!match)
 	return false;
 
     return !extract_signed(match.slice(1, 3)).fail;
 }
 
-function remove_hachette_cookies(header)
+function remove_haketilo_cookies(header)
 {
     if (header.name !== "Cookie")
 	return header;
 
     const cookies = header.value.split("; ");
-    const value = cookies.filter(c => !is_valid_hachette_cookie(c)).join("; ");
+    const value = cookies.filter(c => !is_valid_haketilo_cookie(c)).join("; ");
 
     return value ? {name: "Cookie", value} : null;
 }
 
 function filter_cookie_headers(headers)
 {
-    return headers.map(remove_hachette_cookies).filter(h => h);
+    return headers.map(remove_haketilo_cookies).filter(h => h);
 }
 
 /*
diff --git a/background/main.js b/background/main.js
index 03cd5d7..40b3a9e 100644
--- a/background/main.js
+++ b/background/main.js
@@ -1,5 +1,7 @@
 /**
- * Hachette main background script
+ * This file is part of Haketilo.
+ *
+ * Function: Main background script.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/background/page_actions_server.js b/background/page_actions_server.js
index e21ca6e..156a79f 100644
--- a/background/page_actions_server.js
+++ b/background/page_actions_server.js
@@ -1,5 +1,7 @@
 /**
- * Hachette serving of page actions to content scripts
+ * This file is part of Haketilo.
+ *
+ * Function: Serving page actions to content scripts.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/background/policy_injector.js b/background/policy_injector.js
index e5af055..881595b 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -1,5 +1,7 @@
 /**
- * Hachette injecting policy to page using webRequest
+ * This file is part of Haketilo.
+ *
+ * Function: Injecting policy to page by modifying HTTP headers.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Copyright (C) 2021 jahoti
@@ -19,10 +21,10 @@ function inject_csp_headers(headers, policy)
 {
     let csp_headers;
     let old_signature;
-    let hachette_header;
+    let haketilo_header;
 
-    for (const header of headers.filter(h => h.name === "x-hachette")) {
-	/* x-hachette header has format: <signature>_0_<data> */
+    for (const header of headers.filter(h => h.name === "x-haketilo")) {
+	/* x-haketilo header has format: <signature>_0_<data> */
 	const match = /^([^_]+)_(0_.*)$/.exec(header.value);
 	if (!match)
 	    continue;
@@ -38,7 +40,7 @@ function inject_csp_headers(headers, policy)
 	csp_headers = old_data.csp_headers;
 	old_signature = old_data.policy_sig;
 
-	hachette_header = header;
+	haketilo_header = header;
 	break;
     }
 
@@ -53,9 +55,9 @@ function inject_csp_headers(headers, policy)
 	headers.push(...csp_headers || []);
     }
 
-    if (!hachette_header) {
-	hachette_header = {name: "x-hachette"};
-	headers.push(hachette_header);
+    if (!haketilo_header) {
+	haketilo_header = {name: "x-haketilo"};
+	headers.push(haketilo_header);
     }
 
     if (old_signature)
@@ -66,7 +68,7 @@ function inject_csp_headers(headers, policy)
     const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
     headers.push({
 	name: "Set-Cookie",
-	value: `hachette-${signed_policy.join("=")}; Expires=${later_30sec};`
+	value: `haketilo-${signed_policy.join("=")}; Expires=${later_30sec};`
     });
 
     /*
@@ -74,9 +76,9 @@ function inject_csp_headers(headers, policy)
      * These are signed with a time of 0, as it's not clear there is a limit on
      * how long Firefox might retain headers in the cache.
      */
-    let hachette_data = {csp_headers, policy_sig: signed_policy[0]};
-    hachette_data = encodeURIComponent(JSON.stringify(hachette_data));
-    hachette_header.value = sign_data(hachette_data, 0).join("_");
+    let haketilo_data = {csp_headers, policy_sig: signed_policy[0]};
+    haketilo_data = encodeURIComponent(JSON.stringify(haketilo_data));
+    haketilo_header.value = sign_data(haketilo_data, 0).join("_");
 
     if (!policy.allow) {
 	headers.push({
diff --git a/background/storage.js b/background/storage.js
index 12c0c61..a4e626a 100644
--- a/background/storage.js
+++ b/background/storage.js
@@ -1,5 +1,7 @@
 /**
- * Hachette storage manager
+ * This file is part of Haketilo.
+ *
+ * Function: Storage manager.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/background/storage_server.js b/background/storage_server.js
index 2252eb5..73126d4 100644
--- a/background/storage_server.js
+++ b/background/storage_server.js
@@ -1,5 +1,7 @@
 /**
- * Hachette storage through connection (server side)
+ * This file is part of Haketilo.
+ *
+ * Function: Storage through messages (server side).
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/background/stream_filter.js b/background/stream_filter.js
index 3e30a4b..e5e0827 100644
--- a/background/stream_filter.js
+++ b/background/stream_filter.js
@@ -1,5 +1,7 @@
 /**
- * Hachette modifying a web page using the StreamFilter API
+ * This file is part of Haketilo.
+ *
+ * Function: Modifying a web page using the StreamFilter API.
  *
  * Copyright (C) 2018 Giorgio Maone <giorgio@maone.net>
  * Copyright (C) 2021 Wojtek Kosior
@@ -173,7 +175,7 @@ function filter_data(properties, event)
 	 */
 
 	const dummy_script =
-	      `<script data-hachette-deleteme="${properties.policy.nonce}" nonce="${properties.policy.nonce}">null</script>`;
+	      `<script data-haketilo-deleteme="${properties.policy.nonce}" nonce="${properties.policy.nonce}">null</script>`;
 	const doctype_decl = /^(\s*<!doctype[^<>"']*>)?/i.exec(decoded)[0];
 	decoded = doctype_decl + dummy_script +
 	    decoded.substring(doctype_decl.length);
diff --git a/common/ajax.js b/common/ajax.js
index 8082bbe..7269a8a 100644
--- a/common/ajax.js
+++ b/common/ajax.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Wrapping XMLHttpRequest into a Promise.
+ * This file is part of Haketilo.
+ *
+ * Function: Wrapping XMLHttpRequest into a Promise.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/connection_types.js b/common/connection_types.js
index 88c6964..3e9df56 100644
--- a/common/connection_types.js
+++ b/common/connection_types.js
@@ -1,5 +1,7 @@
 /**
- * Hachette background scripts message connection types "enum"
+ * This file is part of Haketilo.
+ *
+ * Function: Define an "enum" of message connection types.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/lock.js b/common/lock.js
index 822ad1b..6cf0835 100644
--- a/common/lock.js
+++ b/common/lock.js
@@ -1,5 +1,7 @@
 /**
- * Hachette lock (aka binary semaphore aka mutex)
+ * This file is part of Haketilo.
+ *
+ * Function: Implement a lock (aka binary semaphore aka mutex).
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/message_server.js b/common/message_server.js
index ea40487..c8c6696 100644
--- a/common/message_server.js
+++ b/common/message_server.js
@@ -1,5 +1,7 @@
 /**
- * Hachette message server
+ * This file is part of Haketilo.
+ *
+ * Function: Message server.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/misc.js b/common/misc.js
index 6cded84..9ffb7ff 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -1,5 +1,7 @@
 /**
- * Hachette miscellaneous operations refactored to a separate file
+ * This file is part of Haketilo.
+ *
+ * Function: Miscellaneous operations refactored to a separate file.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Copyright (C) 2021 jahoti
diff --git a/common/observable.js b/common/observable.js
index 02f1c1b..ab3b444 100644
--- a/common/observable.js
+++ b/common/observable.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Facilitate listening to events
+ * This file is part of Haketilo.
+ *
+ * Function: Facilitate listening to (internal, self-generated) events.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/once.js b/common/once.js
index 098b43f..93e842f 100644
--- a/common/once.js
+++ b/common/once.js
@@ -1,5 +1,8 @@
 /**
- * Hachette feature initialization promise
+ * This file is part of Haketilo.
+ *
+ * Function: Wrap APIs that depend on some asynchronous initialization into
+ *     promises.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/patterns.js b/common/patterns.js
index ae29fcd..625be05 100644
--- a/common/patterns.js
+++ b/common/patterns.js
@@ -1,5 +1,7 @@
 /**
- * Hachette operations on page url patterns
+ * This file is part of Haketilo.
+ *
+ * Function: Operations on page URL patterns.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/sanitize_JSON.js b/common/sanitize_JSON.js
index 8b86d2d..4cf1ef4 100644
--- a/common/sanitize_JSON.js
+++ b/common/sanitize_JSON.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Powerful, full-blown format enforcer for externally-obtained JSON
+ * This file is part of Haketilo.
+ *
+ * Function: Powerful, full-blown format enforcer for externally-obtained JSON.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/settings_query.js b/common/settings_query.js
index b54e580..7e1315e 100644
--- a/common/settings_query.js
+++ b/common/settings_query.js
@@ -1,5 +1,7 @@
 /**
- * Hachette querying page settings with regard to wildcard records
+ * This file is part of Haketilo.
+ *
+ * Function: Querying page settings.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/signing.js b/common/signing.js
index 1904bcd..11cd442 100644
--- a/common/signing.js
+++ b/common/signing.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Functions related to "signing" of data, refactored to a separate file.
+ * This file is part of Haketilo.
+ *
+ * Functions: Operations related to "signing" of data.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
@@ -16,7 +17,7 @@
 
 /*
  * In order to make certain data synchronously accessible in certain contexts,
- * hachette smuggles it in string form in places like cookies, URLs and headers.
+ * Haketilo smuggles it in string form in places like cookies, URLs and headers.
  * When using the smuggled data, we first need to make sure it isn't spoofed.
  * For that, we use this pseudo-signing mechanism.
  *
diff --git a/common/storage_client.js b/common/storage_client.js
index 2b2f495..ef4a0b8 100644
--- a/common/storage_client.js
+++ b/common/storage_client.js
@@ -1,5 +1,7 @@
 /**
- * Hachette storage through connection (client side)
+ * This file is part of Haketilo.
+ *
+ * Function: Storage through messages (client side).
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/storage_light.js b/common/storage_light.js
index 067bf0c..32e3b1f 100644
--- a/common/storage_light.js
+++ b/common/storage_light.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Storage manager, lighter than the previous one.
+ * This file is part of Haketilo.
+ *
+ * Function: Storage manager, lighter than the previous one.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/storage_raw.js b/common/storage_raw.js
index 4c02ee4..e354b6b 100644
--- a/common/storage_raw.js
+++ b/common/storage_raw.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Basic wrappers for storage API functions.
+ * This file is part of Haketilo.
+ *
+ * Function: Basic wrappers for storage API functions.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/common/stored_types.js b/common/stored_types.js
index bfceba6..a693b1c 100644
--- a/common/stored_types.js
+++ b/common/stored_types.js
@@ -1,5 +1,7 @@
 /**
- * Hachette stored item types "enum"
+ * This file is part of Haketilo.
+ *
+ * Function: Define an "enum" of stored item types.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/content/activity_info_server.js b/content/activity_info_server.js
index 1b69703..d1dfe36 100644
--- a/content/activity_info_server.js
+++ b/content/activity_info_server.js
@@ -1,7 +1,8 @@
 /**
- * part of Hachette
- * Informing about activities performed by content script (script injection,
- * script blocking).
+ * This file is part of Haketilo.
+ *
+ * Function: Informing the popup about what happens in the content script
+ *     (script injection, script blocking, etc.).
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/content/main.js b/content/main.js
index 6478ea0..cec9943 100644
--- a/content/main.js
+++ b/content/main.js
@@ -1,5 +1,7 @@
 /**
- * Hachette main content script run in all frames
+ * This file is part of Haketilo.
+ *
+ * Function: Main content script that runs in all frames.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Copyright (C) 2021 jahoti
@@ -33,7 +35,7 @@ function extract_cookie_policy(cookie, min_time)
     let policy = null;
     const extracted_signatures = [];
 
-    for (const match of cookie.matchAll(/hachette-(\w*)=([^;]*)/g)) {
+    for (const match of cookie.matchAll(/haketilo-(\w*)=([^;]*)/g)) {
 	const new_result = extract_signed(...match.slice(1, 3));
 	if (new_result.fail)
 	    continue;
@@ -60,7 +62,7 @@ function extract_url_policy(url, min_time)
     const [base_url, payload, anchor] =
 	  /^([^#]*)#?([^#]*)(#?.*)$/.exec(url).splice(1, 4);
 
-    const match = /^hachette_([^_]+)_(.*)$/.exec(payload);
+    const match = /^haketilo_([^_]+)_(.*)$/.exec(payload);
     if (!match)
 	return [null, url];
 
@@ -83,7 +85,7 @@ function employ_nonhttp_policy(policy)
     policy.nonce = gen_nonce();
     const [base_url, target] = /^([^#]*)(#?.*)$/.exec(policy.url).slice(1, 3);
     const encoded_policy = encodeURIComponent(JSON.stringify(policy));
-    const payload = "hachette_" +
+    const payload = "haketilo_" +
 	  sign_data(encoded_policy, new Date().getTime()).join("_");
     const resulting_url = `${base_url}#${payload}${target}`;
     location.href = resulting_url;
@@ -187,7 +189,7 @@ function sanitize_meta(meta)
 
 function sanitize_script(script)
 {
-    script.hachette_blocked_type = script.getAttribute("type");
+    script.haketilo_blocked_type = script.getAttribute("type");
     script.type = "text/plain";
 }
 
@@ -197,12 +199,12 @@ function sanitize_script(script)
  */
 function desanitize_script(script)
 {
-    script.setAttribute("type", script.hachette_blocked_type);
+    script.setAttribute("type", script.haketilo_blocked_type);
 
-    if ([null, undefined].includes(script.hachette_blocked_type))
+    if ([null, undefined].includes(script.haketilo_blocked_type))
 	script.removeAttribute("type");
 
-    delete script.hachette_blocked_type;
+    delete script.haketilo_blocked_type;
 }
 
 const bad_url_reg = /^data:([^,;]*ml|unknown-content-type)/i;
@@ -235,7 +237,7 @@ function start_data_urls_sanitizing(doc)
  */
 function prevent_script_execution(event)
 {
-    if (!event.target._hachette_payload)
+    if (!event.target.haketilo_payload)
 	event.preventDefault();
 }
 
@@ -336,7 +338,7 @@ if (!is_privileged_url(document.URL)) {
 	let signatures;
 	[policy, signatures] = extract_cookie_policy(document.cookie, min_time);
 	for (const signature of signatures)
-	    document.cookie = `hachette-${signature}=; Max-Age=-1;`;
+	    document.cookie = `haketilo-${signature}=; Max-Age=-1;`;
     } else {
 	const scheme = /^([^:]*)/.exec(document.URL)[1];
 	const known_scheme = ["file", "ftp"].includes(scheme);
diff --git a/content/page_actions.js b/content/page_actions.js
index 040b4ab..db7c352 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -1,5 +1,7 @@
 /**
- * Hachette handling of page actions in content scripts
+ * This file is part of Haketilo.
+ *
+ * Function: Handle page actions in a content script.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
@@ -60,7 +62,7 @@ function add_script(script_text)
     let script = document.createElement("script");
     script.textContent = script_text;
     script.setAttribute("nonce", nonce);
-    script._hachette_payload = true;
+    script.haketilo_payload = true;
     document.body.appendChild(script);
 
     report_script(script_text);
diff --git a/content/repo_query.js b/content/repo_query.js
index 3708108..637282c 100644
--- a/content/repo_query.js
+++ b/content/repo_query.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Getting available content for site from remote repositories.
+ * This file is part of Haketilo.
+ *
+ * Function: Getting available content for site from remote repositories.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/copyright b/copyright
index 4c37eb3..fe2aed7 100644
--- a/copyright
+++ b/copyright
@@ -1,5 +1,5 @@
 Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: Hachette
+Upstream-Name: Haketilo
 Source: https://git.koszko.org/browser-extension/
 
 Files: *
diff --git a/html/DOM_helpers.js b/html/DOM_helpers.js
index 01e2be9..4fe118d 100644
--- a/html/DOM_helpers.js
+++ b/html/DOM_helpers.js
@@ -1,5 +1,7 @@
 /**
- * Hachette operations on DOM elements
+ * This file is part of Haketilo.
+ *
+ * Function: Operations on DOM elements.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/MOZILLA_scrollbar_fix.css b/html/MOZILLA_scrollbar_fix.css
index 5feb7c3..cdbd5c6 100644
--- a/html/MOZILLA_scrollbar_fix.css
+++ b/html/MOZILLA_scrollbar_fix.css
@@ -1,6 +1,8 @@
 /**
- * Hachette
- * Hacky fix for vertical scrollbar width being included in child's width.
+ * This file is part of Haketilo.
+ *
+ * Function: Hacky fix for vertical scrollbar width being included in child's
+ *     width.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/back_button.css b/html/back_button.css
index 1ddc5da..b83e834 100644
--- a/html/back_button.css
+++ b/html/back_button.css
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Style for a "back" button with a CSS arrow image.
+ * This file is part of Haketilo.
+ *
+ * Function: Style for a "back" button with a CSS arrow image.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/base.css b/html/base.css
index df52f7c..517a5c1 100644
--- a/html/base.css
+++ b/html/base.css
@@ -1,5 +1,7 @@
 /**
- * Hachette base styles
+ * This file is part of Haketilo.
+ *
+ * Function: Base styles.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Copyright (C) 2021 Nicholas Johnson
diff --git a/html/default_blocking_policy.js b/html/default_blocking_policy.js
index 2f49bac..b6458f3 100644
--- a/html/default_blocking_policy.js
+++ b/html/default_blocking_policy.js
@@ -1,6 +1,7 @@
 /**
- * part of Hachette
- * Default policy dialog logic.
+ * This file is part of Haketilo.
+ *
+ * Function: Logic for the dialog of default policy selection.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/display-panel.html b/html/display-panel.html
index 3ed1b7a..ee9e767 100644
--- a/html/display-panel.html
+++ b/html/display-panel.html
@@ -1,12 +1,16 @@
 <!doctype html>
 <!--
+    This file is part of Haketilo.
+
+    Function: Extension's popup page.
+
     Copyright (C) 2021 Wojtek Kosior
     Redistribution terms are gathered in the `copyright' file.
   -->
 <html>
   <head>
     <meta charset="utf-8"/>
-    <title>Hachette - page settings</title>
+    <title>Haketilo - page settings</title>
     <link type="text/css" rel="stylesheet" href="reset.css" />
     <link type="text/css" rel="stylesheet" href="base.css" />
     <link type="text/css" rel="stylesheet" href="back_button.css" />
@@ -331,7 +335,7 @@
 
       <div class="footer padding_inline has_upper_thin_line">
 	<button id="settings_but" type="button">
-	  Open Hachette settings
+	  Open Haketilo settings
 	</button>
       </div>
     </div>
diff --git a/html/display-panel.js b/html/display-panel.js
index 84c922f..c078850 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -1,5 +1,7 @@
 /**
- * Hachette display panel logic
+ * This file is part of Haketilo.
+ *
+ * Function: Popup logic.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/import_frame.js b/html/import_frame.js
index c0eb2f0..ae6fab4 100644
--- a/html/import_frame.js
+++ b/html/import_frame.js
@@ -1,5 +1,7 @@
 /**
- * Hachette HTML import frame script
+ * This file is part of Haketilo.
+ *
+ * Function: Logic for the settings import frame.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/html/options.html b/html/options.html
index 54ab9e8..2e8317c 100644
--- a/html/options.html
+++ b/html/options.html
@@ -1,12 +1,16 @@
 <!doctype html>
 <!--
+    This file is part of Haketilo.
+
+    Function: Extension's settings page.
+
     Copyright (C) 2021 Wojtek Kosior
     Redistribution terms are gathered in the `copyright' file.
   -->
 <html>
   <head>
     <meta charset="utf-8"/>
-    <title>Hachette options</title>
+    <title>Haketilo options</title>
     <link type="text/css" rel="stylesheet" href="reset.css" />
     <link type="text/css" rel="stylesheet" href="base.css" />
     <link type="text/css" rel="stylesheet" href="table.css" />
diff --git a/html/options_main.js b/html/options_main.js
index 27ab0ec..f8faf9b 100644
--- a/html/options_main.js
+++ b/html/options_main.js
@@ -1,5 +1,7 @@
 /**
- * Hachette HTML options page main script
+ * This file is part of Haketilo.
+ *
+ * Function: Settings page logic.
  *
  * Copyright (C) 2021 Wojtek Kosior
  * Redistribution terms are gathered in the `copyright' file.
diff --git a/icons/hachette.svg b/icons/hachette.svg
deleted file mode 100644
index 6e8948d..0000000
--- a/icons/hachette.svg
+++ /dev/null
@@ -1,127 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   width="128"
-   height="128"
-   viewBox="0 -0.6 33.866668 33.866666"
-   version="1.1"
-   id="svg8">
-  <title
-     id="title1418">Hatchet</title>
-  <defs
-     id="defs2">
-    <filter
-       style="color-interpolation-filters:sRGB"
-       id="filter994"
-       x="-0.78125864"
-       width="2.5625174"
-       y="-0.25392297"
-       height="1.5078459">
-      <feGaussianBlur
-         stdDeviation="1.7304741"
-         id="feGaussianBlur996" />
-    </filter>
-    <filter
-       style="color-interpolation-filters:sRGB"
-       id="filter1401"
-       x="-0.43681362"
-       width="1.8736273"
-       y="-0.032828163"
-       height="1.0656563">
-      <feGaussianBlur
-         stdDeviation="2.2606587"
-         id="feGaussianBlur1403" />
-    </filter>
-  </defs>
-  <metadata
-     id="metadata5">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title>Hatchet</dc:title>
-        <dc:creator>
-          <cc:Agent>
-            <dc:title>David Lyons</dc:title>
-          </cc:Agent>
-        </dc:creator>
-        <dc:publisher>
-          <cc:Agent>
-            <dc:title>dlyons</dc:title>
-          </cc:Agent>
-        </dc:publisher>
-        <cc:license
-           rdf:resource="http://creativecommons.org/licenses/by-sa/4.0/" />
-        <dc:date>2017-05</dc:date>
-        <dc:subject>
-          <rdf:Bag>
-            <rdf:li>hatchet</rdf:li>
-            <rdf:li>ax</rdf:li>
-            <rdf:li>wood</rdf:li>
-          </rdf:Bag>
-        </dc:subject>
-        <dc:description>Hatchet</dc:description>
-      </cc:Work>
-      <cc:License
-         rdf:about="http://creativecommons.org/licenses/by-sa/4.0/">
-        <cc:permits
-           rdf:resource="http://creativecommons.org/ns#Reproduction" />
-        <cc:permits
-           rdf:resource="http://creativecommons.org/ns#Distribution" />
-        <cc:requires
-           rdf:resource="http://creativecommons.org/ns#Notice" />
-        <cc:requires
-           rdf:resource="http://creativecommons.org/ns#Attribution" />
-        <cc:permits
-           rdf:resource="http://creativecommons.org/ns#DerivativeWorks" />
-        <cc:requires
-           rdf:resource="http://creativecommons.org/ns#ShareAlike" />
-      </cc:License>
-    </rdf:RDF>
-  </metadata>
-  <g
-     transform="matrix(0.18053177,-0.14666587,0.14666587,0.18053177,-0.67884005,5.998568)"
-     id="g4514">
-    <path
-       style="fill:#d38d5f;stroke-width:0.23824416"
-       d="M 7.30405,153.7586 C 20.54927,112.215 15.59359,34.229537 16.31646,33.113187 c 0.87975,-1.35862 11.98736,-0.3859 11.70824,-0.21673 0.17326,45.22237 7.01132,84.510963 -0.71993,131.991763 l -9.29885,-5.88681 z"
-       id="rect7" />
-    <path
-       style="stroke-width:0.27389684"
-       d="m 63.328435,18.175599 c 0,0 -18.017818,8.640905 -27.631388,12.644707 -3.823279,1.592294 -7.11998,3.047871 -9.996289,4.376476 -11.35319,0.247708 -19.4479991,0.01005 -19.8799245,1.450041 l 0.01602,16.049149 c 0.1225108,1.704999 8.9933655,2.136989 19.9713905,3.333131 6.538886,4.233937 13.307605,8.532834 17.153475,10.714075 9.058079,5.13742 18.504813,7.823295 18.504813,7.823295 0,0 5.056977,-21.237215 4.911847,-31.707625 C 66.23324,32.388436 63.328435,18.175599 63.328435,18.175599 Z"
-       id="rect9" />
-    <path
-       id="path35"
-       d="m 63.328435,18.175599 c 0,0 2.905055,14.268926 3.050195,24.739336 0.14513,10.47041 -4.912098,31.651538 -4.912098,31.651538 -11.67798,-3.788669 -16.221256,-6.527691 -16.221256,-6.527691 0,0 7.434244,-7.591907 9.174294,-22.366997 1.1592,-16.80443 -4.045711,-21.40711 -4.045711,-21.40711 3.905919,-1.879065 11.01257,-5.216217 12.954576,-6.089076 z"
-       style="opacity:0.45500004;fill:#ffffff;stroke-width:0.26458335" />
-    <path
-       style="opacity:0.45500004;fill:#ffffff;stroke-width:0.26458335"
-       d="m 63.208938,17.51176 c 0,0 3.024552,14.932765 3.169692,25.403175 0.14513,10.47041 -4.912098,31.621519 -4.912098,31.621519 -1.568463,-0.523507 -1.541936,-0.491688 -1.541936,-0.491688 0,0 5.456154,-26.034461 5.211644,-30.225191 -0.0315,-4.2355 -1.218109,-20.314453 -3.453104,-24.783592 0,0 0.723943,-0.407792 1.645299,-0.860384 z"
-       id="path1427" />
-    <path
-       style="fill:#784421;stroke:none;stroke-width:0.26458335px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="m 7.30405,153.7586 10.40103,5.0627 c 0,0 9.14195,5.35641 9.55606,6.02467 0.41411,0.66827 -4.66818,-0.88342 -7.90926,-2.11367 -3.24108,-1.23026 -8.21159,-4.9245 -10.36004,-6.6929 -2.14844,-1.76841 -1.68779,-2.2808 -1.68779,-2.2808 z"
-       id="path1407" />
-    <path
-       id="path999"
-       d="M 7.30405,153.7586 C 17.372688,112.40594 21.015256,78.343761 17.898744,32.568697 l 3.350934,-0.138515 c 0.131707,45.014525 3.851339,79.911868 -2.025736,127.174438 z"
-       style="opacity:0.3;fill:#2b1100;stroke-width:0.20724197" />
-    <path
-       style="opacity:1;fill:#1a1a1a;stroke:none;stroke-width:0.1832249"
-       d="m 37.364038,35.560531 9.400174,-5.992052 c 4.831746,9.986754 3.508267,19.973509 -0.303231,29.960263 l -9.096943,-5.992051 z"
-       id="rect4493" />
-    <rect
-       style="opacity:1;fill:#1a1a1a;stroke:none;stroke-width:0.37082145"
-       id="rect4504"
-       width="7.4658442"
-       height="15.338916"
-       x="23.754957"
-       y="38.224262" />
-  </g>
-</svg>
diff --git a/icons/hachette128.png b/icons/hachette128.png
deleted file mode 100644
index 18816e9..0000000
Binary files a/icons/hachette128.png and /dev/null differ
diff --git a/icons/hachette16.png b/icons/hachette16.png
deleted file mode 100644
index 182ede5..0000000
Binary files a/icons/hachette16.png and /dev/null differ
diff --git a/icons/hachette32.png b/icons/hachette32.png
deleted file mode 100644
index ffaa84b..0000000
Binary files a/icons/hachette32.png and /dev/null differ
diff --git a/icons/hachette48.png b/icons/hachette48.png
deleted file mode 100644
index 1ffcd38..0000000
Binary files a/icons/hachette48.png and /dev/null differ
diff --git a/icons/hachette64.png b/icons/hachette64.png
deleted file mode 100644
index a02abb0..0000000
Binary files a/icons/hachette64.png and /dev/null differ
diff --git a/icons/haketilo.svg b/icons/haketilo.svg
new file mode 100644
index 0000000..6e8948d
--- /dev/null
+++ b/icons/haketilo.svg
@@ -0,0 +1,127 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   width="128"
+   height="128"
+   viewBox="0 -0.6 33.866668 33.866666"
+   version="1.1"
+   id="svg8">
+  <title
+     id="title1418">Hatchet</title>
+  <defs
+     id="defs2">
+    <filter
+       style="color-interpolation-filters:sRGB"
+       id="filter994"
+       x="-0.78125864"
+       width="2.5625174"
+       y="-0.25392297"
+       height="1.5078459">
+      <feGaussianBlur
+         stdDeviation="1.7304741"
+         id="feGaussianBlur996" />
+    </filter>
+    <filter
+       style="color-interpolation-filters:sRGB"
+       id="filter1401"
+       x="-0.43681362"
+       width="1.8736273"
+       y="-0.032828163"
+       height="1.0656563">
+      <feGaussianBlur
+         stdDeviation="2.2606587"
+         id="feGaussianBlur1403" />
+    </filter>
+  </defs>
+  <metadata
+     id="metadata5">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title>Hatchet</dc:title>
+        <dc:creator>
+          <cc:Agent>
+            <dc:title>David Lyons</dc:title>
+          </cc:Agent>
+        </dc:creator>
+        <dc:publisher>
+          <cc:Agent>
+            <dc:title>dlyons</dc:title>
+          </cc:Agent>
+        </dc:publisher>
+        <cc:license
+           rdf:resource="http://creativecommons.org/licenses/by-sa/4.0/" />
+        <dc:date>2017-05</dc:date>
+        <dc:subject>
+          <rdf:Bag>
+            <rdf:li>hatchet</rdf:li>
+            <rdf:li>ax</rdf:li>
+            <rdf:li>wood</rdf:li>
+          </rdf:Bag>
+        </dc:subject>
+        <dc:description>Hatchet</dc:description>
+      </cc:Work>
+      <cc:License
+         rdf:about="http://creativecommons.org/licenses/by-sa/4.0/">
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#Reproduction" />
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#Distribution" />
+        <cc:requires
+           rdf:resource="http://creativecommons.org/ns#Notice" />
+        <cc:requires
+           rdf:resource="http://creativecommons.org/ns#Attribution" />
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#DerivativeWorks" />
+        <cc:requires
+           rdf:resource="http://creativecommons.org/ns#ShareAlike" />
+      </cc:License>
+    </rdf:RDF>
+  </metadata>
+  <g
+     transform="matrix(0.18053177,-0.14666587,0.14666587,0.18053177,-0.67884005,5.998568)"
+     id="g4514">
+    <path
+       style="fill:#d38d5f;stroke-width:0.23824416"
+       d="M 7.30405,153.7586 C 20.54927,112.215 15.59359,34.229537 16.31646,33.113187 c 0.87975,-1.35862 11.98736,-0.3859 11.70824,-0.21673 0.17326,45.22237 7.01132,84.510963 -0.71993,131.991763 l -9.29885,-5.88681 z"
+       id="rect7" />
+    <path
+       style="stroke-width:0.27389684"
+       d="m 63.328435,18.175599 c 0,0 -18.017818,8.640905 -27.631388,12.644707 -3.823279,1.592294 -7.11998,3.047871 -9.996289,4.376476 -11.35319,0.247708 -19.4479991,0.01005 -19.8799245,1.450041 l 0.01602,16.049149 c 0.1225108,1.704999 8.9933655,2.136989 19.9713905,3.333131 6.538886,4.233937 13.307605,8.532834 17.153475,10.714075 9.058079,5.13742 18.504813,7.823295 18.504813,7.823295 0,0 5.056977,-21.237215 4.911847,-31.707625 C 66.23324,32.388436 63.328435,18.175599 63.328435,18.175599 Z"
+       id="rect9" />
+    <path
+       id="path35"
+       d="m 63.328435,18.175599 c 0,0 2.905055,14.268926 3.050195,24.739336 0.14513,10.47041 -4.912098,31.651538 -4.912098,31.651538 -11.67798,-3.788669 -16.221256,-6.527691 -16.221256,-6.527691 0,0 7.434244,-7.591907 9.174294,-22.366997 1.1592,-16.80443 -4.045711,-21.40711 -4.045711,-21.40711 3.905919,-1.879065 11.01257,-5.216217 12.954576,-6.089076 z"
+       style="opacity:0.45500004;fill:#ffffff;stroke-width:0.26458335" />
+    <path
+       style="opacity:0.45500004;fill:#ffffff;stroke-width:0.26458335"
+       d="m 63.208938,17.51176 c 0,0 3.024552,14.932765 3.169692,25.403175 0.14513,10.47041 -4.912098,31.621519 -4.912098,31.621519 -1.568463,-0.523507 -1.541936,-0.491688 -1.541936,-0.491688 0,0 5.456154,-26.034461 5.211644,-30.225191 -0.0315,-4.2355 -1.218109,-20.314453 -3.453104,-24.783592 0,0 0.723943,-0.407792 1.645299,-0.860384 z"
+       id="path1427" />
+    <path
+       style="fill:#784421;stroke:none;stroke-width:0.26458335px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 7.30405,153.7586 10.40103,5.0627 c 0,0 9.14195,5.35641 9.55606,6.02467 0.41411,0.66827 -4.66818,-0.88342 -7.90926,-2.11367 -3.24108,-1.23026 -8.21159,-4.9245 -10.36004,-6.6929 -2.14844,-1.76841 -1.68779,-2.2808 -1.68779,-2.2808 z"
+       id="path1407" />
+    <path
+       id="path999"
+       d="M 7.30405,153.7586 C 17.372688,112.40594 21.015256,78.343761 17.898744,32.568697 l 3.350934,-0.138515 c 0.131707,45.014525 3.851339,79.911868 -2.025736,127.174438 z"
+       style="opacity:0.3;fill:#2b1100;stroke-width:0.20724197" />
+    <path
+       style="opacity:1;fill:#1a1a1a;stroke:none;stroke-width:0.1832249"
+       d="m 37.364038,35.560531 9.400174,-5.992052 c 4.831746,9.986754 3.508267,19.973509 -0.303231,29.960263 l -9.096943,-5.992051 z"
+       id="rect4493" />
+    <rect
+       style="opacity:1;fill:#1a1a1a;stroke:none;stroke-width:0.37082145"
+       id="rect4504"
+       width="7.4658442"
+       height="15.338916"
+       x="23.754957"
+       y="38.224262" />
+  </g>
+</svg>
diff --git a/icons/haketilo128.png b/icons/haketilo128.png
new file mode 100644
index 0000000..18816e9
Binary files /dev/null and b/icons/haketilo128.png differ
diff --git a/icons/haketilo16.png b/icons/haketilo16.png
new file mode 100644
index 0000000..182ede5
Binary files /dev/null and b/icons/haketilo16.png differ
diff --git a/icons/haketilo32.png b/icons/haketilo32.png
new file mode 100644
index 0000000..ffaa84b
Binary files /dev/null and b/icons/haketilo32.png differ
diff --git a/icons/haketilo48.png b/icons/haketilo48.png
new file mode 100644
index 0000000..1ffcd38
Binary files /dev/null and b/icons/haketilo48.png differ
diff --git a/icons/haketilo64.png b/icons/haketilo64.png
new file mode 100644
index 0000000..a02abb0
Binary files /dev/null and b/icons/haketilo64.png differ
diff --git a/manifest.json b/manifest.json
index ce2577e..9d34732 100644
--- a/manifest.json
+++ b/manifest.json
@@ -1,18 +1,20 @@
+// This is the manifest file of Haketilo.
+//
 // Copyright (C) 2021 Wojtek Kosior
 // Redistribution terms are gathered in the `copyright' file.
 {
     "manifest_version": 2,
-    "name": "Hachette",
-    "short_name": "Hachette",
+    "name": "Haketilo",
+    "short_name": "Haketilo",
     "version": "0.0.1",
     "author": "various",
     "description": "Control your \"Web\" browsing.",_GECKO_APPLICATIONS_
     "icons":{
-	"128": "icons/hachette128.png",
-	"64": "icons/hachette64.png",
-	"48": "icons/hachette48.png",
-	"32": "icons/hachette32.png",
-	"16": "icons/hachette16.png"
+	"128": "icons/haketilo128.png",
+	"64": "icons/haketilo64.png",
+	"48": "icons/haketilo48.png",
+	"32": "icons/haketilo32.png",
+	"16": "icons/haketilo16.png"
     },
     "permissions": [
 	"contextMenus",
@@ -29,13 +31,13 @@
     "browser_action": {
 	"browser_style": true,
 	"default_icon": {
-	    "128": "icons/hachette128.png",
-	    "64": "icons/hachette64.png",
-	    "48": "icons/hachette48.png",
-	    "32": "icons/hachette32.png",
-	    "16": "icons/hachette16.png"
+	    "128": "icons/haketilo128.png",
+	    "64": "icons/haketilo64.png",
+	    "48": "icons/haketilo48.png",
+	    "32": "icons/haketilo32.png",
+	    "16": "icons/haketilo16.png"
 	},
-	"default_title": "Hachette",
+	"default_title": "Haketilo",
 	"default_popup": "html/display-panel.html"
     },
     "options_ui": {
diff --git a/re-generate_icons.sh b/re-generate_icons.sh
index ba0c28a..e557ad0 100755
--- a/re-generate_icons.sh
+++ b/re-generate_icons.sh
@@ -4,5 +4,5 @@
 # Redistribution terms are gathered in the `copyright' file.
 
 for SIZE in 128 64 48 32 16; do
-    inkscape -z -e icons/hachette$SIZE.png -w $SIZE -h $SIZE icons/hachette.svg
+    inkscape -z -e icons/haketilo$SIZE.png -w $SIZE -h $SIZE icons/haketilo.svg
 done
-- 
cgit v1.2.3


From 96068ada37bfa1d7e6485551138ba36600664caf Mon Sep 17 00:00:00 2001
From: Wojtek Kosior <koszko@koszko.org>
Date: Sat, 20 Nov 2021 18:29:59 +0100
Subject: replace cookies with synchronous XmlHttpRequest as policy smuggling
 method.

Note: this breaks Mozilla port of Haketilo. Synchronous XmlHttpRequest doesn't work as well there. This will be fixed with dynamically-registered content scripts later.
---
 background/cookie_filter.js       |  46 -------------
 background/main.js                | 120 +++++++++++++++++++++++++++------
 background/page_actions_server.js |  32 ++-------
 background/policy_injector.js     |  67 +++---------------
 background/stream_filter.js       |   6 +-
 build.sh                          |  16 +----
 common/misc.js                    |   2 +-
 common/signing.js                 |  74 --------------------
 content/activity_info_server.js   |   4 +-
 content/main.js                   | 138 +++++++++++---------------------------
 content/page_actions.js           |  27 ++++----
 dummy                             |   0
 html/display-panel.js             |  13 ++--
 manifest.json                     |   3 +-
 14 files changed, 180 insertions(+), 368 deletions(-)
 delete mode 100644 background/cookie_filter.js
 delete mode 100644 common/signing.js
 create mode 100644 dummy

(limited to 'content/main.js')

diff --git a/background/cookie_filter.js b/background/cookie_filter.js
deleted file mode 100644
index 64d18b2..0000000
--- a/background/cookie_filter.js
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- * This file is part of Haketilo.
- *
- * Function: Filtering request headers to remove haketilo cookies that might
- *     have slipped through.
- *
- * Copyright (C) 2021 Wojtek Kosior
- * Redistribution terms are gathered in the `copyright' file.
- */
-
-/*
- * IMPORTS_START
- * IMPORT extract_signed
- * IMPORTS_END
- */
-
-function is_valid_haketilo_cookie(cookie)
-{
-    const match = /^haketilo-(\w*)=(.*)$/.exec(cookie);
-    if (!match)
-	return false;
-
-    return !extract_signed(match.slice(1, 3)).fail;
-}
-
-function remove_haketilo_cookies(header)
-{
-    if (header.name !== "Cookie")
-	return header;
-
-    const cookies = header.value.split("; ");
-    const value = cookies.filter(c => !is_valid_haketilo_cookie(c)).join("; ");
-
-    return value ? {name: "Cookie", value} : null;
-}
-
-function filter_cookie_headers(headers)
-{
-    return headers.map(remove_haketilo_cookies).filter(h => h);
-}
-
-/*
- * EXPORTS_START
- * EXPORT filter_cookie_headers
- * EXPORTS_END
- */
diff --git a/background/main.js b/background/main.js
index 40b3a9e..9cdfb97 100644
--- a/background/main.js
+++ b/background/main.js
@@ -17,11 +17,10 @@
  * IMPORT browser
  * IMPORT is_privileged_url
  * IMPORT query_best
- * IMPORT gen_nonce
  * IMPORT inject_csp_headers
  * IMPORT apply_stream_filter
- * IMPORT filter_cookie_headers
  * IMPORT is_chrome
+ * IMPORT is_mozilla
  * IMPORTS_END
  */
 
@@ -51,34 +50,53 @@ async function init_ext(install_details)
 
 browser.runtime.onInstalled.addListener(init_ext);
 
+/*
+ * The function below implements a more practical interface for what it does by
+ * wrapping the old query_best() function.
+ */
+function decide_policy_for_url(storage, policy_observable, url)
+{
+    if (storage === undefined)
+	return {allow: false};
+
+    const settings =
+	{allow: policy_observable !== undefined && policy_observable.value};
+
+    const [pattern, queried_settings] = query_best(storage, url);
+
+    if (queried_settings) {
+	settings.payload = queried_settings.components;
+	settings.allow = !!queried_settings.allow && !settings.payload;
+	settings.pattern = pattern;
+    }
+
+    return settings;
+}
 
 let storage;
 let policy_observable = {};
 
-function on_headers_received(details)
+function sanitize_web_page(details)
 {
     const url = details.url;
     if (is_privileged_url(details.url))
 	return;
 
-    const [pattern, settings] = query_best(storage, details.url);
-    const has_payload = !!(settings && settings.components);
-    const allow = !has_payload &&
-	  !!(settings ? settings.allow : policy_observable.value);
-    const nonce = gen_nonce();
-    const policy = {allow, url, nonce, has_payload};
+    const policy =
+	  decide_policy_for_url(storage, policy_observable, details.url);
 
     let headers = details.responseHeaders;
+
+    headers = inject_csp_headers(headers, policy);
+
     let skip = false;
     for (const header of headers) {
 	if ((header.name.toLowerCase().trim() === "content-disposition" &&
 	     /^\s*attachment\s*(;.*)$/i.test(header.value)))
 	    skip = true;
     }
-
-    headers = inject_csp_headers(headers, policy);
-
     skip = skip || (details.statusCode >= 300 && details.statusCode < 400);
+
     if (!skip) {
 	/* Check for API availability. */
 	if (browser.webRequest.filterResponseData)
@@ -88,11 +106,49 @@ function on_headers_received(details)
     return {responseHeaders: headers};
 }
 
-function on_before_send_headers(details)
+const request_url_regex = /^[^?]*\?url=(.*)$/;
+const redirect_url_template = browser.runtime.getURL("dummy") + "?settings=";
+
+function synchronously_smuggle_policy(details)
 {
-    let headers = details.requestHeaders;
-    headers = filter_cookie_headers(headers);
-    return {requestHeaders: headers};
+    /*
+     * Content script will make a synchronous XmlHttpRequest to extension's
+     * `dummy` file to query settings for given URL. We smuggle that
+     * information in query parameter of the URL we redirect to.
+     * A risk of fingerprinting arises if a page with script execution allowed
+     * guesses the dummy file URL and makes an AJAX call to it. It is currently
+     * a problem in ManifestV2 Chromium-family port of Haketilo because Chromium
+     * uses predictable URLs for web-accessible resources. We plan to fix it in
+     * the future ManifestV3 port.
+     */
+    if (details.type !== "xmlhttprequest")
+	return {cancel: true};
+
+    console.debug(`Settings queried using XHR for '${details.url}'.`);
+
+    let policy = {allow: false};
+
+    try {
+	/*
+	 * request_url should be of the following format:
+	 *     <url_for_extension's_dummy_file>?url=<valid_urlencoded_url>
+	 */
+	const match = request_url_regex.exec(details.url);
+	const queried_url = decodeURIComponent(match[1]);
+
+	if (details.initiator && !queried_url.startsWith(details.initiator)) {
+	    console.warn(`Blocked suspicious query of '${url}' by '${details.initiator}'. This might be the result of page fingerprinting the browser.`);
+	    return {cancel: true};
+	}
+
+	policy = decide_policy_for_url(storage, policy_observable, queried_url);
+    } catch (e) {
+	console.warn(`Bad request! Expected ${browser.runtime.getURL("dummy")}?url=<valid_urlencoded_url>. Got ${request_url}. This might be the result of page fingerprinting the browser.`);
+    }
+
+    const encoded_policy = encodeURIComponent(JSON.stringify(policy));
+
+    return {redirectUrl: redirect_url_template + encoded_policy};
 }
 
 const all_types = [
@@ -110,18 +166,40 @@ async function start_webRequest_operations()
 	extra_opts.push("extraHeaders");
 
     browser.webRequest.onHeadersReceived.addListener(
-	on_headers_received,
+	sanitize_web_page,
 	{urls: ["<all_urls>"], types: ["main_frame", "sub_frame"]},
 	extra_opts.concat("responseHeaders")
     );
 
-    browser.webRequest.onBeforeSendHeaders.addListener(
-	on_before_send_headers,
-	{urls: ["<all_urls>"], types: all_types},
-	extra_opts.concat("requestHeaders")
+    const dummy_url_pattern = browser.runtime.getURL("dummy") + "?url=*";
+    browser.webRequest.onBeforeRequest.addListener(
+	synchronously_smuggle_policy,
+	{urls: [dummy_url_pattern], types: ["xmlhttprequest"]},
+	extra_opts
     );
 
     policy_observable = await light_storage.observe_var("default_allow");
 }
 
 start_webRequest_operations();
+
+const code = `\
+console.warn("Hi, I'm Mr Dynamic!");
+
+console.debug("let's see how window.killtheweb looks like now");
+
+console.log("killtheweb", window.killtheweb);
+`
+
+async function test_dynamic_content_scripts()
+{
+    browser.contentScripts.register({
+	"js": [{code}],
+	"matches": ["<all_urls>"],
+	"allFrames": true,
+	"runAt": "document_start"
+});
+}
+
+if (is_mozilla)
+    test_dynamic_content_scripts();
diff --git a/background/page_actions_server.js b/background/page_actions_server.js
index 156a79f..74783c9 100644
--- a/background/page_actions_server.js
+++ b/background/page_actions_server.js
@@ -16,34 +16,12 @@
  * IMPORT browser
  * IMPORT listen_for_connection
  * IMPORT sha256
- * IMPORT query_best
  * IMPORT make_ajax_request
  * IMPORTS_END
  */
 
 var storage;
 var handler;
-let policy_observable;
-
-function send_actions(url, port)
-{
-    const [pattern, queried_settings] = query_best(storage, url);
-
-    const settings = {allow: policy_observable && policy_observable.value};
-    Object.assign(settings, queried_settings);
-    if (settings.components)
-	settings.allow = false;
-
-    const repos = storage.get_all(TYPE_PREFIX.REPO);
-
-    port.postMessage(["settings", [pattern, settings, repos]]);
-
-    const components = settings.components;
-    const processed_bags = new Set();
-
-    if (components !== undefined)
-	send_scripts([components], port, processed_bags);
-}
 
 // TODO: parallelize script fetching
 async function send_scripts(components, port, processed_bags)
@@ -116,9 +94,11 @@ async function fetch_remote_script(script_data)
 function handle_message(port, message, handler)
 {
     port.onMessage.removeListener(handler[0]);
-    let url = message.url;
-    console.log({url});
-    send_actions(url, port);
+    console.debug(`Loading payload '${message.payload}'.`);
+
+    const processed_bags = new Set();
+
+    send_scripts([message.payload], port, processed_bags);
 }
 
 function new_connection(port)
@@ -134,8 +114,6 @@ async function start_page_actions_server()
     storage = await get_storage();
 
     listen_for_connection(CONNECTION_TYPE.PAGE_ACTIONS, new_connection);
-
-    policy_observable = await light_storage.observe_var("default_allow");
 }
 
 /*
diff --git a/background/policy_injector.js b/background/policy_injector.js
index 881595b..b49ec47 100644
--- a/background/policy_injector.js
+++ b/background/policy_injector.js
@@ -10,77 +10,28 @@
 
 /*
  * IMPORTS_START
- * IMPORT sign_data
- * IMPORT extract_signed
  * IMPORT make_csp_rule
  * IMPORT csp_header_regex
+ * Re-enable the import below once nonce stuff here is ready
+ * !mport gen_nonce
  * IMPORTS_END
  */
 
 function inject_csp_headers(headers, policy)
 {
     let csp_headers;
-    let old_signature;
-    let haketilo_header;
 
-    for (const header of headers.filter(h => h.name === "x-haketilo")) {
-	/* x-haketilo header has format: <signature>_0_<data> */
-	const match = /^([^_]+)_(0_.*)$/.exec(header.value);
-	if (!match)
-	    continue;
+    if (policy.payload) {
+	headers = headers.filter(h => !csp_header_regex.test(h.name));
 
-	const result = extract_signed(...match.slice(1, 3));
-	if (result.fail)
-	    continue;
+	// TODO: make CSP rules with nonces and facilitate passing them to
+	// content scripts via dynamic content script registration or
+	// synchronous XHRs
 
-	/* This should succeed - it's our self-produced valid JSON. */
-	const old_data = JSON.parse(decodeURIComponent(result.data));
-
-	/* Confirmed- it's the originals, smuggled in! */
-	csp_headers = old_data.csp_headers;
-	old_signature = old_data.policy_sig;
-
-	haketilo_header = header;
-	break;
+	// policy.nonce = gen_nonce();
     }
 
-    if (policy.has_payload) {
-	csp_headers = [];
-	const non_csp_headers = [];
-	const header_list =
-	      h => csp_header_regex.test(h) ? csp_headers : non_csp_headers;
-	headers.forEach(h => header_list(h.name).push(h));
-	headers = non_csp_headers;
-    } else {
-	headers.push(...csp_headers || []);
-    }
-
-    if (!haketilo_header) {
-	haketilo_header = {name: "x-haketilo"};
-	headers.push(haketilo_header);
-    }
-
-    if (old_signature)
-	headers = headers.filter(h => h.value.search(old_signature) === -1);
-
-    const policy_str = encodeURIComponent(JSON.stringify(policy));
-    const signed_policy = sign_data(policy_str, new Date().getTime());
-    const later_30sec = new Date(new Date().getTime() + 30000).toGMTString();
-    headers.push({
-	name: "Set-Cookie",
-	value: `haketilo-${signed_policy.join("=")}; Expires=${later_30sec};`
-    });
-
-    /*
-     * Smuggle in the signature and the original CSP headers for future use.
-     * These are signed with a time of 0, as it's not clear there is a limit on
-     * how long Firefox might retain headers in the cache.
-     */
-    let haketilo_data = {csp_headers, policy_sig: signed_policy[0]};
-    haketilo_data = encodeURIComponent(JSON.stringify(haketilo_data));
-    haketilo_header.value = sign_data(haketilo_data, 0).join("_");
-
-    if (!policy.allow) {
+    if (!policy.allow && (policy.nonce || !policy.payload)) {
 	headers.push({
 	    name: "content-security-policy",
 	    value: make_csp_rule(policy)
diff --git a/background/stream_filter.js b/background/stream_filter.js
index e5e0827..e5d124c 100644
--- a/background/stream_filter.js
+++ b/background/stream_filter.js
@@ -174,8 +174,7 @@ function filter_data(properties, event)
 	 * as harmless anyway).
 	 */
 
-	const dummy_script =
-	      `<script data-haketilo-deleteme="${properties.policy.nonce}" nonce="${properties.policy.nonce}">null</script>`;
+	const dummy_script = `<script>null</script>`;
 	const doctype_decl = /^(\s*<!doctype[^<>"']*>)?/i.exec(decoded)[0];
 	decoded = doctype_decl + dummy_script +
 	    decoded.substring(doctype_decl.length);
@@ -189,11 +188,10 @@ function filter_data(properties, event)
 
 function apply_stream_filter(details, headers, policy)
 {
-    if (!policy.has_payload)
+    if (!policy.payload)
 	return headers;
 
     const properties = properties_from_headers(headers);
-    properties.policy = policy;
 
     properties.filter =
 	browser.webRequest.filterResponseData(details.requestId);
diff --git a/build.sh b/build.sh
index 936ab06..ed6a141 100755
--- a/build.sh
+++ b/build.sh
@@ -180,7 +180,6 @@ build_main() {
 	mkdir -p "$BUILDDIR"/$DIR
     done
 
-    CHROMIUM_KEY=''
     CHROMIUM_UPDATE_URL=''
     GECKO_APPLICATIONS=''
 
@@ -189,20 +188,7 @@ build_main() {
     fi
 
     if [ "$BROWSER" = "chromium" ]; then
-	CHROMIUM_KEY="$(dd if=/dev/urandom bs=32 count=1 2>/dev/null | base64)"
-	CHROMIUM_KEY=$(echo chromium-key-dummy-file-$CHROMIUM_KEY | tr / -)
-	touch "$BUILDDIR"/$CHROMIUM_KEY
-
 	CHROMIUM_UPDATE_URL="$UPDATE_URL"
-
-	CHROMIUM_KEY="\n\
-	// WARNING!!!\n\
-	// EACH USER SHOULD REPLACE DUMMY FILE's VALUE WITH A UNIQUE ONE!!!\n\
-	// OTHERWISE, SECURITY CAN BE TRIVIALLY COMPROMISED!\n\
-	// Only relevant to users of chrome-based browsers.\n\
-	// Users of Firefox forks are safe.\n\
-	\"$CHROMIUM_KEY\"\
-"
     else
 	GECKO_APPLICATIONS="\n\
     \"applications\": {\n\
@@ -215,7 +201,6 @@ build_main() {
 
     sed "\
 s^_GECKO_APPLICATIONS_^$GECKO_APPLICATIONS^
-s^_CHROMIUM_KEY_^$CHROMIUM_KEY^
 s^_CHROMIUM_UPDATE_URL_^$CHROMIUM_UPDATE_URL^
 s^_BGSCRIPTS_^$BGSCRIPTS^
 s^_CONTENTSCRIPTS_^$CONTENTSCRIPTS^" \
@@ -279,6 +264,7 @@ EOF
     fi
 
     cp -r copyright licenses/ "$BUILDDIR"
+    cp dummy "$BUILDDIR"
     cp html/*.css "$BUILDDIR"/html
     mkdir "$BUILDDIR"/icons
     cp icons/*.png "$BUILDDIR"/icons
diff --git a/common/misc.js b/common/misc.js
index 9ffb7ff..5b0addb 100644
--- a/common/misc.js
+++ b/common/misc.js
@@ -49,7 +49,7 @@ function gen_nonce(length=16)
 function make_csp_rule(policy)
 {
     let rule = "prefetch-src 'none'; script-src-attr 'none';";
-    const script_src = policy.has_payload ?
+    const script_src = policy.nonce !== undefined ?
 	  `'nonce-${policy.nonce}'` : "'none'";
     rule += ` script-src ${script_src}; script-src-elem ${script_src};`;
     return rule;
diff --git a/common/signing.js b/common/signing.js
deleted file mode 100644
index 11cd442..0000000
--- a/common/signing.js
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * This file is part of Haketilo.
- *
- * Functions: Operations related to "signing" of data.
- *
- * Copyright (C) 2021 Wojtek Kosior
- * Redistribution terms are gathered in the `copyright' file.
- */
-
-/*
- * IMPORTS_START
- * IMPORT sha256
- * IMPORT browser
- * IMPORT is_mozilla
- * IMPORTS_END
- */
-
-/*
- * In order to make certain data synchronously accessible in certain contexts,
- * Haketilo smuggles it in string form in places like cookies, URLs and headers.
- * When using the smuggled data, we first need to make sure it isn't spoofed.
- * For that, we use this pseudo-signing mechanism.
- *
- * Despite what name suggests, no assymetric cryptography is involved, as it
- * would bring no additional benefits and would incur bigger performance
- * overhead. Instead, we hash the string data together with some secret value
- * that is supposed to be known only by this browser instance. Resulting hash
- * sum plays the role of the signature. In the hash we also include current
- * time. This way, even if signed data leaks (which shouldn't happen in the
- * first place), an attacker won't be able to re-use it indefinitely.
- *
- * The secret shared between execution contexts has to be available
- * synchronously. Under Mozilla, this is the extension's per-session id. Under
- * Chromium, this is a dummy web-accessible-resource name that resides in the
- * manifest and is supposed to be constructed by each user using a unique value
- * (this is done automatically by `build.sh').
- */
-
-function get_secret()
-{
-    if (is_mozilla)
-	return browser.runtime.getURL("dummy");
-
-    return chrome.runtime.getManifest().web_accessible_resources
-	.map(r => /^chromium-key-dummy-file-(.*)/.exec(r)).filter(r => r)[0][1];
-}
-
-function extract_signed(signature, signed_data)
-{
-    const match = /^([1-9][0-9]{12}|0)_(.*)$/.exec(signed_data);
-    if (!match)
-	return {fail: "bad format"};
-
-    const result = {time: parseInt(match[1]), data: match[2]};
-    if (sign_data(result.data, result.time)[0] !== signature)
-	result.fail = "bad signature";
-
-    return result;
-}
-
-/*
- * Sign a given string for a given time. Time should be either 0 or in the range
- * 10^12 <= time < 10^13.
- */
-function sign_data(data, time) {
-    return [sha256(get_secret() + time + data), `${time}_${data}`];
-}
-
-/*
- * EXPORTS_START
- * EXPORT extract_signed
- * EXPORT sign_data
- * EXPORTS_END
- */
diff --git a/content/activity_info_server.js b/content/activity_info_server.js
index d1dfe36..aa92b75 100644
--- a/content/activity_info_server.js
+++ b/content/activity_info_server.js
@@ -42,7 +42,9 @@ function report_script(script_data)
 
 function report_settings(settings)
 {
-    report_activity("settings", settings);
+    const settings_clone = {};
+    Object.assign(settings_clone, settings)
+    report_activity("settings", settings_clone);
 }
 
 function report_document_type(is_html)
diff --git a/content/main.js b/content/main.js
index cec9943..ce1ff7a 100644
--- a/content/main.js
+++ b/content/main.js
@@ -11,15 +11,15 @@
 /*
  * IMPORTS_START
  * IMPORT handle_page_actions
- * IMPORT extract_signed
- * IMPORT sign_data
  * IMPORT gen_nonce
  * IMPORT is_privileged_url
+ * IMPORT browser
  * IMPORT is_chrome
  * IMPORT is_mozilla
  * IMPORT start_activity_info_server
  * IMPORT make_csp_rule
  * IMPORT csp_header_regex
+ * IMPORT report_settings
  * IMPORTS_END
  */
 
@@ -29,69 +29,6 @@ const wait_loaded = e => e.content_loaded ? Promise.resolve() :
 
 wait_loaded(document).then(() => document.content_loaded = true);
 
-function extract_cookie_policy(cookie, min_time)
-{
-    let best_result = {time: -1};
-    let policy = null;
-    const extracted_signatures = [];
-
-    for (const match of cookie.matchAll(/haketilo-(\w*)=([^;]*)/g)) {
-	const new_result = extract_signed(...match.slice(1, 3));
-	if (new_result.fail)
-	    continue;
-
-	extracted_signatures.push(match[1]);
-
-	if (new_result.time < Math.max(min_time, best_result.time))
-	    continue;
-
-	/* This should succeed - it's our self-produced valid JSON. */
-	const new_policy = JSON.parse(decodeURIComponent(new_result.data));
-	if (new_policy.url !== document.URL)
-	    continue;
-
-	best_result = new_result;
-	policy = new_policy;
-    }
-
-    return [policy, extracted_signatures];
-}
-
-function extract_url_policy(url, min_time)
-{
-    const [base_url, payload, anchor] =
-	  /^([^#]*)#?([^#]*)(#?.*)$/.exec(url).splice(1, 4);
-
-    const match = /^haketilo_([^_]+)_(.*)$/.exec(payload);
-    if (!match)
-	return [null, url];
-
-    const result = extract_signed(...match.slice(1, 3));
-    if (result.fail)
-	return [null, url];
-
-    const original_url = base_url + anchor;
-    const policy = result.time < min_time ? null :
-	  JSON.parse(decodeURIComponent(result.data));
-
-    return [policy.url === original_url ? policy : null, original_url];
-}
-
-function employ_nonhttp_policy(policy)
-{
-    if (!policy.allow)
-	return;
-
-    policy.nonce = gen_nonce();
-    const [base_url, target] = /^([^#]*)(#?.*)$/.exec(policy.url).slice(1, 3);
-    const encoded_policy = encodeURIComponent(JSON.stringify(policy));
-    const payload = "haketilo_" +
-	  sign_data(encoded_policy, new Date().getTime()).join("_");
-    const resulting_url = `${base_url}#${payload}${target}`;
-    location.href = resulting_url;
-    location.reload();
-}
-
 /*
  * In the case of HTML documents:
  * 1. When injecting some payload we need to sanitize <meta> CSP tags before
@@ -306,7 +243,7 @@ http-equiv="Content-Security-Policy" content="${make_csp_rule(policy)}"\
     start_data_urls_sanitizing(doc);
 }
 
-async function disable_service_workers()
+async function _disable_service_workers()
 {
     if (!navigator.serviceWorker)
 	return;
@@ -315,7 +252,7 @@ async function disable_service_workers()
     if (registrations.length === 0)
 	return;
 
-    console.warn("Service Workers detected on this page! Unregistering and reloading");
+    console.warn("Service Workers detected on this page! Unregistering and reloading.");
 
     try {
 	await Promise.all(registrations.map(r => r.unregister()));
@@ -327,50 +264,57 @@ async function disable_service_workers()
     return new Promise(() => 0);
 }
 
-if (!is_privileged_url(document.URL)) {
-    let policy_received_callback = () => undefined;
-    let policy;
-
-    /* Signature valid for half an hour. */
-    const min_time = new Date().getTime() - 1800 * 1000;
-
-    if (/^https?:/.test(document.URL)) {
-	let signatures;
-	[policy, signatures] = extract_cookie_policy(document.cookie, min_time);
-	for (const signature of signatures)
-	    document.cookie = `haketilo-${signature}=; Max-Age=-1;`;
-    } else {
-	const scheme = /^([^:]*)/.exec(document.URL)[1];
-	const known_scheme = ["file", "ftp"].includes(scheme);
-
-	if (!known_scheme)
-	    console.warn(`Unknown url scheme: \`${scheme}'!`);
-
-	let original_url;
-	[policy, original_url] = extract_url_policy(document.URL, min_time);
-	history.replaceState(null, "", original_url);
-
-	if (known_scheme && !policy)
-	    policy_received_callback = employ_nonhttp_policy;
+/*
+ * Trying to use servce workers APIs might result in exceptions, for example
+ * when in a non-HTML document. Because of this, we wrap the function that does
+ * the actual work in a try {} block.
+ */
+async function disable_service_workers()
+{
+    try {
+	await _disable_service_workers()
+    } catch (e) {
+	console.debug("Exception thrown during an attempt to detect and disable service workers.", e);
     }
+}
 
-    if (!policy) {
-	console.debug("Using fallback policy!");
-	policy = {allow: false, nonce: gen_nonce()};
+function synchronously_get_policy(url)
+{
+    const encoded_url = encodeURIComponent(url);
+    const request_url = `${browser.runtime.getURL("dummy")}?url=${encoded_url}`;
+
+    try {
+	var xhttp = new XMLHttpRequest();
+	xhttp.open("GET", request_url, false);
+	xhttp.send();
+    } catch(e) {
+	console.error("Failure to synchronously fetch policy for url.", e);
+	return {allow: false};
     }
 
+    const policy = /^[^?]*\?settings=(.*)$/.exec(xhttp.responseURL)[1];
+    return JSON.parse(decodeURIComponent(policy));
+}
+
+if (!is_privileged_url(document.URL)) {
+    const policy = synchronously_get_policy(document.URL);
+
     if (!(document instanceof HTMLDocument))
-	policy.has_payload = false;
+	delete policy.payload;
 
     console.debug("current policy", policy);
 
+    report_settings(policy);
+
+    policy.nonce = gen_nonce();
+
     const doc_ready = Promise.all([
 	policy.allow ? Promise.resolve() : sanitize_document(document, policy),
 	policy.allow ? Promise.resolve() : disable_service_workers(),
 	wait_loaded(document)
     ]);
 
-    handle_page_actions(policy.nonce, policy_received_callback, doc_ready);
+    handle_page_actions(policy, doc_ready);
 
     start_activity_info_server();
 }
diff --git a/content/page_actions.js b/content/page_actions.js
index db7c352..845e452 100644
--- a/content/page_actions.js
+++ b/content/page_actions.js
@@ -12,19 +12,17 @@
  * IMPORT CONNECTION_TYPE
  * IMPORT browser
  * IMPORT report_script
- * IMPORT report_settings
  * IMPORT report_document_type
  * IMPORTS_END
  */
 
-let policy_received_callback;
+let policy;
 /* Snapshot url and content type early; these can be changed by other code. */
 let url;
 let is_html;
 let port;
 let loaded = false;
 let scripts_awaiting = [];
-let nonce;
 
 function handle_message(message)
 {
@@ -38,9 +36,8 @@ function handle_message(message)
 		scripts_awaiting.push(script_text);
 	}
     }
-    if (action === "settings") {
-	report_settings(data);
-	policy_received_callback({url, allow: data[1].allow});
+    else {
+	console.error(`Bad page action '${action}'.`);
     }
 }
 
@@ -61,27 +58,27 @@ function add_script(script_text)
 
     let script = document.createElement("script");
     script.textContent = script_text;
-    script.setAttribute("nonce", nonce);
+    script.setAttribute("nonce", policy.nonce);
     script.haketilo_payload = true;
     document.body.appendChild(script);
 
     report_script(script_text);
 }
 
-function handle_page_actions(script_nonce, policy_received_cb,
-			     doc_ready_promise) {
-    policy_received_callback = policy_received_cb;
+function handle_page_actions(_policy, doc_ready_promise) {
+    policy = _policy;
+
     url = document.URL;
     is_html = document instanceof HTMLDocument;
     report_document_type(is_html);
 
     doc_ready_promise.then(document_ready);
 
-    port = browser.runtime.connect({name : CONNECTION_TYPE.PAGE_ACTIONS});
-    port.onMessage.addListener(handle_message);
-    port.postMessage({url});
-
-    nonce = script_nonce;
+    if (policy.payload) {
+	port = browser.runtime.connect({name : CONNECTION_TYPE.PAGE_ACTIONS});
+	port.onMessage.addListener(handle_message);
+	port.postMessage({payload: policy.payload});
+    }
 }
 
 /*
diff --git a/dummy b/dummy
new file mode 100644
index 0000000..e69de29
diff --git a/html/display-panel.js b/html/display-panel.js
index c078850..4fe0173 100644
--- a/html/display-panel.js
+++ b/html/display-panel.js
@@ -229,14 +229,14 @@ function handle_activity_report(message)
     const [type, data] = message;
 
     if (type === "settings") {
-	let [pattern, settings] = data;
+	const settings = data;
 
 	blocked_span.textContent = settings.allow ? "no" : "yes";
 
-	if (pattern) {
+	if (settings.pattern) {
 	    pattern_span.textContent = pattern;
 	    const settings_opener =
-		  () => open_in_settings(TYPE_PREFIX.PAGE, pattern);
+		  () => open_in_settings(TYPE_PREFIX.PAGE, settings.pattern);
 	    view_pattern_but.classList.remove("hide");
 	    view_pattern_but.addEventListener("click", settings_opener);
 	} else {
@@ -244,11 +244,10 @@ function handle_activity_report(message)
 	    blocked_span.textContent = blocked_span.textContent + " (default)";
 	}
 
-	const components = settings.components;
-	if (components) {
-	    payload_span.textContent = nice_name(...components);
+	if (settings.payload) {
+	    payload_span.textContent = nice_name(...settings.payload);
 	    payload_buttons_div.classList.remove("hide");
-	    const settings_opener = () => open_in_settings(...components);
+	    const settings_opener = () => open_in_settings(...settings.payload);
 	    view_payload_but.addEventListener("click", settings_opener);
 	} else {
 	    payload_span.textContent = "none";
diff --git a/manifest.json b/manifest.json
index b18ea3e..7b4cb26 100644
--- a/manifest.json
+++ b/manifest.json
@@ -44,8 +44,7 @@
 	"page": "html/options.html",
 	"open_in_tab": true
     }_CHROMIUM_UPDATE_URL_,
-    "web_accessible_resources": [_CHROMIUM_KEY_
-    ],
+    "web_accessible_resources": ["dummy"],
     "background": {
 	"persistent": true,
 	"scripts": [_BGSCRIPTS_]
-- 
cgit v1.2.3