Haketilo

let default_allow = {};

#EXPORT default_allow

this.haketilo_secret        = ${JSON.stringify(secret)};

this.haketilo_pattern_tree  = ${JSON.stringify(tree)};

this.haketilo_default_allow = ${JSON.stringify(default_allow.value)};

    const set_allow_val = ch => default_allow.value = (ch.new_val || {}).value;

    const [setting_tracking, initial_settings] =

	  await haketilodb.track.settings(set_allow_val);

    for (const setting of initial_settings) {

	if (setting.name === "default_allow")

	    Object.assign(default_allow, setting);

    }

#FROM background/patterns_query_manager.js IMPORT tree, default_allow

    const policy =

	  decide_policy(tree, details.url, !!default_allow.value, secret);

#IF MOZILLA

const priv_reg = /^moz-extension:\/\/|^about:|^file:\/\/[^?#]*\/([?#]|$)/;

#ELIF CHROMIUM

const priv_reg = /^chrome(-extension)?:\/\/|^about:|^file:\/\/[^?#]*\/([?#]|$)/;

#ENDIF

#EXPORT  url => priv_reg.test(url)  AS is_privileged_url

/**

 * This file is part of Haketilo.

 *

 * Function: Content scripts - main script.

 *

 * Copyright (C) 2022 Wojtek Kosior

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * As additional permission under GNU GPL version 3 section 7, you

 * may distribute forms of that code without the copy of the GNU

 * GPL normally required by section 4, provided you include this

 * license notice and, in case of non-source distribution, a URL

 * through which recipients can access the Corresponding Source.

 * If you modify file(s) with this exception, you may extend this

 * exception to your version of the file(s), but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * As a special exception to the GPL, any HTML file which merely

 * makes function calls to this code, and for that purpose

 * includes it by reference shall be deemed a separate work for

 * copyright law purposes. If you modify this code, you may extend

 * this exception to your version of the code, but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 *

 * I, Wojtek Kosior, thereby promise not to sue for violation of this file's

 * license. Although I request that you do not make use of this code in a

 * proprietary program, I am not going to enforce this in court.

 */

#IMPORT content/repo_query_cacher.js

#FROM common/browser.js           IMPORT browser

#FROM common/misc.js              IMPORT is_privileged_url

#FROM common/policy.js            IMPORT decide_policy

#FROM content/policy_enforcing.js IMPORT enforce_blocking

let already_run = false, page_info;

function on_page_info_request([type], sender, respond_cb) {

    if (type !== "page_info")

	return;

    respond_cb(page_info);

}

globalThis.haketilo_content_script_main = function() {

    if (already_run)

        return;

    already_run = true;

    if (is_privileged_url(document.URL))

	return;

    browser.runtime.onMessage.addListener(on_page_info_request);

    repo_query_cacher.start();

    const policy = decide_policy(globalThis.haketilo_pattern_tree,

				 document.URL,

				 globalThis.haketilo_defualt_allow,

				 globalThis.haketilo_secret);

    page_info = Object.assign({url: document.URL}, policy);

    ["csp", "nonce"].forEach(prop => delete page_info[prop]);

    enforce_blocking(policy);

}

function main() {

    if (globalThis.haketilo_pattern_tree !== undefined)

	globalThis.haketilo_content_script_main();

}

#IF !UNIT_TEST

main();

#ENDIF

#IF !UNIT_TEST

	else if (page_info.error)

	    var mapping = `None (error occured when determining policy)`;

# SPDX-License-Identifier: CC0-1.0

"""

Haketilo unit tests - main content script

"""

# This file is part of Haketilo

#

# Copyright (C) 2022 Wojtek Kosior <koszko@koszko.org>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the CC0 1.0 Universal License as published by

# the Creative Commons Corporation.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# CC0 1.0 Universal License for more details.

import pytest

import json

from selenium.webdriver.support.ui import WebDriverWait

from ..script_loader import load_script

# From:

# https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/contentScripts/register

# it is unclear whether the dynamically-registered content script is guaranteed

# to be always executed after statically-registered ones. We want to test both

# cases, so we'll make the mocked dynamic content script execute before

# content.js on http:// pages and after it on https:// pages.

dynamic_script = \

    ''';

    this.haketilo_secret        = "abracadabra";

    this.haketilo_pattern_tree  = {};

    this.haketilo_defualt_allow = false;

    if (this.haketilo_content_script_main)

        this.haketilo_content_script_main();

    '''

content_script = \

    '''

    /* Mock dynamic content script - case 'before'. */

    if (/#dynamic_before$/.test(document.URL)) {

        %s;

    }

    /* Place amalgamated content.js here. */

    %s;

    /* Rest of mocks */

    const data_to_verify = {};

    function data_set(prop, val) {

        data_to_verify[prop] = val;

        window.wrappedJSObject.data_to_verify = JSON.stringify(data_to_verify);

    }

    repo_query_cacher.start = () => data_set("cacher_started", true);

    enforce_blocking = policy => data_set("enforcing", policy);

    browser.runtime.onMessage.addListener = async function (listener_cb) {

        await new Promise(cb => setTimeout(cb, 0));

        /* Mock a good request. */

        const set_good = val => data_set("good_request_result", val);

        listener_cb(["page_info"], {}, val => set_good(val));

        /* Mock a bad request. */

        const set_bad = val => data_set("bad_request_result", val);

        listener_cb(["???"], {}, val => set_bad(val));

    }

    /* main() call - normally present in content.js, inside '#IF !UNIT_TEST'. */

    main();

    /* Mock dynamic content script - case 'after'. */

    if (/#dynamic_after$/.test(document.URL)) {

        %s;

    }

    data_set("script_run_without_errors", true);

    ''' % (dynamic_script, load_script('content/content.js'), dynamic_script)

@pytest.mark.ext_data({'content_script': content_script})

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('target', ['dynamic_before', 'dynamic_after'])

def test_content_unprivileged_page(driver, execute_in_page, target):

    """

    Test functioning of content.js on an page using unprivileged schema (e.g.

    'https://' and not 'about:').

    """

    driver.get(f'https://gotmyowndoma.in/index.html#{target}')

    data = json.loads(driver.execute_script('return window.data_to_verify;'))

    assert 'gotmyowndoma.in' in data['good_request_result']['url']

    assert 'bad_request_result' not in data

    assert data['cacher_started'] == True

    assert data['enforcing']['allow']  == False

    assert 'mapping' not in data['enforcing']

    assert 'error'   not in data['enforcing']

    assert data['script_run_without_errors'] == True

@pytest.mark.ext_data({'content_script': content_script})

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('target', ['dynamic_before', 'dynamic_after'])

def test_content_privileged_page(driver, execute_in_page, target):

    """

    Test functioning of content.js on an page considered privileged (e.g. a

    directory listing at 'file:///').

    """

    driver.get(f'file:///#{target}')

    data = json.loads(driver.execute_script('return window.data_to_verify;'))

    assert data == {'script_run_without_errors': True}

def get_content_script_values(driver, content_script):

    """

    Allow easy extraction of 'this.something = ...' values from generated

    content script and verify the content script is syntactically correct.

    """

    return driver.execute_script(

        '''

        function value_holder() {

            %s;

            return this;

        }

        return value_holder.call({});

        ''' % content_script)

        let mappingchange, blockingchange, settingchange;

        haketilodb.track.settings = function (cb) {

            settingchange = cb;

            return [{}, [{name: "default_allow", value: true}]];

        }

        returnval(start("abracadabra"));

    cs_values = get_content_script_values(driver, content_script)

    assert cs_values['haketilo_secret']        == 'abracadabra'

    assert cs_values['haketilo_pattern_tree']  == tree

    assert cs_values['haketilo_default_allow'] == True

        cs_values = get_content_script_values(driver, last_script)

        return (cs_values['haketilo_default_allow'] == False and

                all([('gotmyown%sdoma' % i) in last_script for i in nums]) and

        const new_setting_val = {name: "default_allow", value: false};

        settingchange({key: "default_allow", new_val: new_setting_val});

        cs_values = get_content_script_values(driver, content_script)

        return cs_values['haketilo_pattern_tree'] == {}

    },

    'error': {

        **unprivileged_page_info,

        'error': True

    if 'blocked' in page_info_key or page_info_key in ('mapping', 'error'):

    if page_info_key == 'error':

        assert mapping_text == 'None (error occured when determining policy)'

            // Mock default allow.

            default_allow = {name: "default_allow", value: true};