Haketilo

/**

 * Hachette miscellaneous operations refactored to a separate file

 *

 * Copyright (C) 2021 Wojtek Kosior

 * Copyright (C) 2021 jahoti

 * Redistribution terms are gathered in the `copyright' file.

 */

/*

 * IMPORTS_START

 * IMPORT sha256

 * IMPORT browser

 * IMPORT is_chrome

 * IMPORT TYPE_NAME

 * IMPORT TYPE_PREFIX

 * IMPORTS_END

 */

/* Generate a random base64-encoded 128-bit sequence */

function gen_nonce()

{

    let randomData = new Uint8Array(16);

    crypto.getRandomValues(randomData);

    return btoa(String.fromCharCode.apply(null, randomData));

}

/*

 * generating unique, per-site value that can be computed synchronously

 * and is impossible to guess for a malicious website

 */

/* Uint8toHex is a separate function not exported as (a) it's useful and (b) it will be used in crypto.subtle-based digests */

function Uint8toHex(data)

{

    let returnValue = '';

    for (let byte of data)

	returnValue += ('00' + byte.toString(16)).slice(-2);

    return returnValue;

}

function gen_nonce(length) // Default 16

{

    let randomData = new Uint8Array(length || 16);

    crypto.getRandomValues(randomData);

    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)

{

    const rule = `'nonce-${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)"

 */

function nice_name(prefix, name)

{

    return `${name} (${TYPE_NAME[prefix]})`;

}

/* Open settings tab with given item's editing already on. */

function open_in_settings(prefix, name)

{

    name = encodeURIComponent(name);

    const url = browser.runtime.getURL("html/options.html#" + 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);

}

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

    let directives = {};

    for (directive of csp.split(';')) {

	directive = directive.trim();

	if (directive === '')

	    continue;

	directive_array = directive.split(/\s+/);

	directive = directive_array.shift();

	/* The "true" case should never occur; nevertheless... */

	directives[directive] = directive in directives ?

	    directives[directive].concat(directive_array) :

	    directive_array;

    }

    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 objest to use as/in schemas for parse_json_with_schema(). */

const nonempty_string_matcher = /.+/;

const matchers = {

    sha256: /^[0-9a-f]{64}$/,

    nonempty_string: nonempty_string_matcher,

    component: [

	new RegExp(`^[${TYPE_PREFIX.SCRIPT}${TYPE_PREFIX.BAG}]$`),

	nonempty_string_matcher

    ]

};

/*

 * EXPORTS_START

 * EXPORT gen_nonce

 * 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

 * EXPORT sanitize_csp_header

 * EXPORT matchers

 * EXPORTS_END

 */