Haketilo

/*

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

const proto_regex = /^(\w+):\/\/(.*)$/;

const path_re = "[^?#]*";

const query_re = "\\??[^#]*";

const http_regex = new RegExp(`^(${domain_re})(${path_re})(${query_re}).*`);

const file_regex = new RegExp(`^(${path_re}).*`);

    const proto_match = proto_regex.exec(url);

    if (proto_match === null)

    const deco = {proto: proto_match[1]};

    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(".");

    }

    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;

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

function* each_domain_pattern(domain_segments)

    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;

}

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

/* Generate every possible pattern that matches url. */

function* each_url_pattern(url)

    const deco = deconstruct_url(url);

    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}`;

    }

 * EXPORT each_url_pattern

 * IMPORT each_url_pattern

    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 : [undefined, undefined];

    console.log("script event", e);

 * IMPORT sign_data

function extract_cookie_policy(cookie, min_time)

{

    for (const match of cookie.matchAll(/hachette-(\w*)=([^;]*)/g)) {

    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;

    }

	console.warn("Using default policy!");

    handle_page_actions(policy.nonce, policy_received_callback);

	if (is_mozilla) {

	    const script = document.querySelector("script");

	    if (script)

		script.textContent = "throw 'blocked';\n" + script.textContent;

	}

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;

    if (action === "settings") {

	policy_received_callback({url, allow: !!data[1] && data[1].allow});

    }

function handle_page_actions(script_nonce, policy_received_cb) {

    policy_received_callback = policy_received_cb;

    url = document.URL;

    port.postMessage({url});

 * IMPORT each_url_pattern

    for (const pattern of each_url_pattern(url))

	add_pattern_to_list(pattern);