Haketilo

    headers = inject_csp_headers(headers, policy);

function inject_csp_headers(headers, policy)

    let csp_headers;

	/* x-hachette header has format: <signature>_0_<data> */

	const match = /^([^_]+)_(0_.*)$/.exec(header.value);

	const result = extract_signed(...match.slice(1, 3));

	if (result.fail)

	/* This should succeed - it's our self-produced valid JSON. */

	const old_data = JSON.parse(decodeURIComponent(result.data));

	csp_headers = old_data.csp_headers;

    csp_headers = csp_headers ||

	headers = headers.filter(h => h.value.search(old_signature) === -1);

    headers.push(...csp_headers.map(h => sanitize_csp_header(h, policy)));

    const signed_policy = sign_data(policy_str, new Date().getTime());

	value: `hachette-${signed_policy.join("=")}; Expires=${later_30sec};`

    let hachette_data = {csp_headers, policy_sig: signed_policy[0]};

    hachette_header.value = sign_data(hachette_data, 0).join("_");

    string = string && string.toLowerCase().trim() || "";

/**

 * 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

 */

    /* 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;

	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!!!");

    for (const signature of extracted_signatures)