@browserless.io/browserless 2.0.0-beta-1

package/extensions/ublock/js/background.js

@@ -0,0 +1,404 @@
+/*******************************************************************************
+
+    uBlock Origin - a browser extension to block requests.
+    Copyright (C) 2014-present Raymond Hill
+
+    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.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see {http://www.gnu.org/licenses/}.
+
+    Home: https://github.com/gorhill/uBlock
+*/
+
+/* globals browser */
+
+'use strict';
+
+/******************************************************************************/
+
+import logger from './logger.js';
+import { FilteringContext } from './filtering-context.js';
+import { ubologSet } from './console.js';
+
+import {
+    domainFromHostname,
+    hostnameFromURI,
+    originFromURI,
+} from './uri-utils.js';
+
+/******************************************************************************/
+
+// Not all platforms may have properly declared vAPI.webextFlavor.
+
+if ( vAPI.webextFlavor === undefined ) {
+    vAPI.webextFlavor = { major: 0, soup: new Set([ 'ublock' ]) };
+}
+
+/******************************************************************************/
+
+const hiddenSettingsDefault = {
+    allowGenericProceduralFilters: false,
+    assetFetchTimeout: 30,
+    autoCommentFilterTemplate: '{{date}} {{origin}}',
+    autoUpdateAssetFetchPeriod: 15,
+    autoUpdateDelayAfterLaunch: 105,
+    autoUpdatePeriod: 1,
+    benchmarkDatasetURL: 'unset',
+    blockingProfiles: '11111/#F00 11010/#C0F 11001/#00F 00001',
+    cacheStorageAPI: 'unset',
+    cacheStorageCompression: true,
+    cacheControlForFirefox1376932: 'no-cache, no-store, must-revalidate',
+    cloudStorageCompression: true,
+    cnameIgnoreList: 'unset',
+    cnameIgnore1stParty: true,
+    cnameIgnoreExceptions: true,
+    cnameIgnoreRootDocument: true,
+    cnameMaxTTL: 120,
+    cnameReplayFullURL: false,
+    cnameUncloakProxied: false,
+    consoleLogLevel: 'unset',
+    debugAssetsJson: false,
+    debugScriptlets: false,
+    debugScriptletInjector: false,
+    differentialUpdate: true,
+    disableWebAssembly: false,
+    extensionUpdateForceReload: false,
+    filterAuthorMode: false,
+    loggerPopupType: 'popup',
+    manualUpdateAssetFetchPeriod: 500,
+    modifyWebextFlavor: 'unset',
+    popupFontSize: 'unset',
+    popupPanelDisabledSections: 0,
+    popupPanelLockedSections: 0,
+    popupPanelHeightMode: 0,
+    requestJournalProcessPeriod: 1000,
+    selfieAfter: 2,
+    strictBlockingBypassDuration: 120,
+    toolbarWarningTimeout: 60,
+    trustedListPrefixes: 'ublock-',
+    uiPopupConfig: 'unset',
+    uiStyles: 'unset',
+    updateAssetBypassBrowserCache: false,
+    userResourcesLocation: 'unset',
+};
+
+if ( vAPI.webextFlavor.soup.has('devbuild') ) {
+    hiddenSettingsDefault.consoleLogLevel = 'info';
+    hiddenSettingsDefault.trustedListPrefixes += ' user-';
+    ubologSet(true);
+}
+
+const userSettingsDefault = {
+    advancedUserEnabled: false,
+    alwaysDetachLogger: true,
+    autoUpdate: true,
+    cloudStorageEnabled: false,
+    cnameUncloakEnabled: true,
+    collapseBlocked: true,
+    colorBlindFriendly: false,
+    contextMenuEnabled: true,
+    uiAccentCustom: false,
+    uiAccentCustom0: '#aca0f7',
+    uiTheme: 'auto',
+    externalLists: '',
+    firewallPaneMinimized: true,
+    hyperlinkAuditingDisabled: true,
+    ignoreGenericCosmeticFilters: vAPI.webextFlavor.soup.has('mobile'),
+    importedLists: [],
+    largeMediaSize: 50,
+    parseAllABPHideFilters: true,
+    popupPanelSections: 0b111,
+    prefetchingDisabled: true,
+    requestLogMaxEntries: 1000,
+    showIconBadge: true,
+    suspendUntilListsAreLoaded: vAPI.Net.canSuspend(),
+    tooltipsDisabled: false,
+    webrtcIPAddressHidden: false,
+};
+
+const dynamicFilteringDefault = [
+    'behind-the-scene * * noop',
+    'behind-the-scene * image noop',
+    'behind-the-scene * 3p noop',
+    'behind-the-scene * inline-script noop',
+    'behind-the-scene * 1p-script noop',
+    'behind-the-scene * 3p-script noop',
+    'behind-the-scene * 3p-frame noop',
+];
+
+const hostnameSwitchesDefault = [
+    'no-large-media: behind-the-scene false',
+];
+// https://github.com/LiCybora/NanoDefenderFirefox/issues/196
+if ( vAPI.webextFlavor.soup.has('firefox') ) {
+    hostnameSwitchesDefault.push('no-csp-reports: * true');
+}
+
+const µBlock = {  // jshint ignore:line
+    userSettingsDefault: userSettingsDefault,
+    userSettings: Object.assign({}, userSettingsDefault),
+
+    hiddenSettingsDefault: hiddenSettingsDefault,
+    hiddenSettingsAdmin: {},
+    hiddenSettings: Object.assign({}, hiddenSettingsDefault),
+
+    dynamicFilteringDefault,
+    hostnameSwitchesDefault,
+
+    noDashboard: false,
+
+    // Features detection.
+    privacySettingsSupported: vAPI.browserSettings instanceof Object,
+    cloudStorageSupported: vAPI.cloud instanceof Object,
+    canFilterResponseData: typeof browser.webRequest.filterResponseData === 'function',
+
+    // https://github.com/chrisaljoudi/uBlock/issues/180
+    // Whitelist directives need to be loaded once the PSL is available
+    netWhitelist: new Map(),
+    netWhitelistModifyTime: 0,
+    netWhitelistDefault: [
+        'about-scheme',
+        'chrome-extension-scheme',
+        'chrome-scheme',
+        'edge-scheme',
+        'moz-extension-scheme',
+        'opera-scheme',
+        'vivaldi-scheme',
+        'wyciwyg-scheme',   // Firefox's "What-You-Cache-Is-What-You-Get"
+    ],
+
+    localSettings: {
+        blockedRequestCount: 0,
+        allowedRequestCount: 0,
+    },
+    localSettingsLastModified: 0,
+
+    // Read-only
+    systemSettings: {
+        compiledMagic: 57,  // Increase when compiled format changes
+        selfieMagic: 57,    // Increase when selfie format changes
+    },
+
+    // https://github.com/uBlockOrigin/uBlock-issues/issues/759#issuecomment-546654501
+    //   The assumption is that cache storage state reflects whether
+    //   compiled or selfie assets are available or not. The properties
+    //   below is to no longer rely on this assumption -- though it's still
+    //   not clear how the assumption could be wrong, and it's still not
+    //   clear whether relying on those properties will really solve the
+    //   issue. It's just an attempt at hardening.
+    compiledFormatChanged: false,
+    selfieIsInvalid: false,
+
+    restoreBackupSettings: {
+        lastRestoreFile: '',
+        lastRestoreTime: 0,
+        lastBackupFile: '',
+        lastBackupTime: 0,
+    },
+
+    commandShortcuts: new Map(),
+
+    // Allows to fully customize uBO's assets, typically set through admin
+    // settings. The content of 'assets.json' will also tell which filter
+    // lists to enable by default when uBO is first installed.
+    assetsBootstrapLocation: undefined,
+
+    assetsJsonPath: vAPI.webextFlavor.soup.has('devbuild')
+        ? '/assets/assets.dev.json'
+        : '/assets/assets.json',
+    userFiltersPath: 'user-filters',
+    pslAssetKey: 'public_suffix_list.dat',
+
+    selectedFilterLists: [],
+    availableFilterLists: {},
+    badLists: new Map(),
+
+    inMemoryFilters: [],
+    inMemoryFiltersCompiled: '',
+
+    // https://github.com/uBlockOrigin/uBlock-issues/issues/974
+    //   This can be used to defer filtering decision-making.
+    readyToFilter: false,
+
+    supportStats: {
+        allReadyAfter: '?',
+        maxAssetCacheWait: '?',
+    },
+
+    pageStores: new Map(),
+    pageStoresToken: 0,
+
+    storageQuota: vAPI.storage.QUOTA_BYTES,
+    storageUsed: 0,
+
+    noopFunc: function(){},
+
+    apiErrorCount: 0,
+
+    maybeGoodPopup: {
+        tabId: 0,
+        url: '',
+    },
+
+    epickerArgs: {
+        eprom: null,
+        mouse: false,
+        target: '',
+        zap: false,
+    },
+
+    scriptlets: {},
+
+    cspNoInlineScript: "script-src 'unsafe-eval' * blob: data:",
+    cspNoScripting: 'script-src http: https:',
+    cspNoInlineFont: 'font-src *',
+
+    liveBlockingProfiles: [],
+    blockingProfileColorCache: new Map(),
+    parsedTrustedListPrefixes: [],
+    uiAccentStylesheet: '',
+};
+
+µBlock.domainFromHostname = domainFromHostname;
+µBlock.hostnameFromURI = hostnameFromURI;
+
+µBlock.FilteringContext = class extends FilteringContext {
+    duplicate() {
+        return (new µBlock.FilteringContext(this));
+    }
+
+    fromTabId(tabId) {
+        const tabContext = µBlock.tabContextManager.mustLookup(tabId);
+        this.tabOrigin = tabContext.origin;
+        this.tabHostname = tabContext.rootHostname;
+        this.tabDomain = tabContext.rootDomain;
+        this.tabId = tabContext.tabId;
+        return this;
+    }
+
+    maybeFromDocumentURL(documentUrl) {
+        if ( documentUrl === undefined ) { return; }
+        if ( documentUrl.startsWith(this.tabOrigin) ) { return; }
+        this.tabOrigin = originFromURI(µBlock.normalizeTabURL(0, documentUrl));
+        this.tabHostname = hostnameFromURI(this.tabOrigin);
+        this.tabDomain = domainFromHostname(this.tabHostname);
+    }
+
+    // https://github.com/uBlockOrigin/uBlock-issues/issues/459
+    //   In case of a request for frame and if ever no context is specified,
+    //   assume the origin of the context is the same as the request itself.
+    fromWebrequestDetails(details) {
+        const tabId = details.tabId;
+        this.type = details.type;
+        const isMainFrame = this.itype === this.MAIN_FRAME;
+        if ( isMainFrame && tabId > 0 ) {
+            µBlock.tabContextManager.push(tabId, details.url);
+        }
+        this.fromTabId(tabId); // Must be called AFTER tab context management
+        this.realm = '';
+        this.id = details.requestId;
+        this.setMethod(details.method);
+        this.setURL(details.url);
+        this.aliasURL = details.aliasURL || undefined;
+        this.redirectURL = undefined;
+        this.filter = undefined;
+        if ( this.itype !== this.SUB_FRAME ) {
+            this.docId = details.frameId;
+            this.frameId = -1;
+        } else {
+            this.docId = details.parentFrameId;
+            this.frameId = details.frameId;
+        }
+        if ( this.tabId > 0 ) {
+            if ( this.docId === 0 ) {
+                if ( isMainFrame === false ) {
+                    this.maybeFromDocumentURL(details.documentUrl);
+                }
+                this.docOrigin = this.tabOrigin;
+                this.docHostname = this.tabHostname;
+                this.docDomain = this.tabDomain;
+                return this;
+            }
+            if ( details.documentUrl !== undefined ) {
+                this.setDocOriginFromURL(details.documentUrl);
+                return this;
+            }
+            const pageStore = µBlock.pageStoreFromTabId(this.tabId);
+            const docStore = pageStore && pageStore.getFrameStore(this.docId);
+            if ( docStore ) {
+                this.setDocOriginFromURL(docStore.rawURL);
+            } else {
+                this.setDocOrigin(this.tabOrigin);
+            }
+            return this;
+        }
+        if ( details.documentUrl !== undefined ) {
+            const origin = originFromURI(
+                µBlock.normalizeTabURL(0, details.documentUrl)
+            );
+            this.setDocOrigin(origin).setTabOrigin(origin);
+            return this;
+        }
+        const origin = (this.itype & this.FRAME_ANY) !== 0
+            ? originFromURI(this.url)
+            : this.tabOrigin;
+        this.setDocOrigin(origin).setTabOrigin(origin);
+        return this;
+    }
+
+    getTabOrigin() {
+        if ( this.tabOrigin === undefined ) {
+            const tabContext = µBlock.tabContextManager.mustLookup(this.tabId);
+            this.tabOrigin = tabContext.origin;
+            this.tabHostname = tabContext.rootHostname;
+            this.tabDomain = tabContext.rootDomain;
+        }
+        return super.getTabOrigin();
+    }
+
+    toLogger() {
+        const details = {
+            id: this.id,
+            tstamp: Date.now(),
+            realm: this.realm,
+            method: this.getMethodName(),
+            type: this.stype,
+            tabId: this.tabId,
+            tabDomain: this.getTabDomain(),
+            tabHostname: this.getTabHostname(),
+            docDomain: this.getDocDomain(),
+            docHostname: this.getDocHostname(),
+            domain: this.getDomain(),
+            hostname: this.getHostname(),
+            url: this.url,
+            aliasURL: this.aliasURL,
+            filter: undefined,
+        };
+        // Many filters may have been applied to the current context
+        if ( Array.isArray(this.filter) === false ) {
+            details.filter = this.filter;
+            return logger.writeOne(details);
+        }
+        for ( const filter of this.filter ) {
+            details.filter = filter;
+            logger.writeOne(details);
+        }
+    }
+};
+
+µBlock.filteringContext = new µBlock.FilteringContext();
+
+self.µBlock = µBlock;
+
+/******************************************************************************/
+
+export default µBlock;

package/extensions/ublock/js/base64-custom.js

@@ -0,0 +1,246 @@
+/*******************************************************************************
+
+    uBlock Origin - a browser extension to block requests.
+    Copyright (C) 2014-present Raymond Hill
+
+    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.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see {http://www.gnu.org/licenses/}.
+
+    Home: https://github.com/gorhill/uBlock
+*/
+
+'use strict';
+
+/******************************************************************************/
+
+// Custom base64 codecs. These codecs are meant to encode/decode typed arrays
+// to/from strings.
+
+// https://github.com/uBlockOrigin/uBlock-issues/issues/461
+//   Provide a fallback encoding for Chromium 59 and less by issuing a plain
+//   JSON string. The fallback can be removed once min supported version is
+//   above 59.
+
+// TODO: rename µBlock.base64 to µBlock.SparseBase64, now that
+//       µBlock.DenseBase64 has been introduced.
+// TODO: Should no longer need to test presence of TextEncoder/TextDecoder.
+
+const valToDigit = new Uint8Array(64);
+const digitToVal = new Uint8Array(128);
+{
+    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@%';
+    for ( let i = 0, n = chars.length; i < n; i++ ) {
+        const c = chars.charCodeAt(i);
+        valToDigit[i] = c;
+        digitToVal[c] = i;
+    }
+}
+
+// The sparse base64 codec is best for buffers which contains a lot of
+// small u32 integer values. Those small u32 integer values are better
+// represented with stringified integers, because small values can be
+// represented with fewer bits than the usual base64 codec. For example,
+// 0 become '0 ', i.e. 16 bits instead of 48 bits with official base64
+// codec.
+
+const sparseBase64 = {
+    magic: 'Base64_1',
+
+    encode: function(arrbuf, arrlen) {
+        const inputLength = (arrlen + 3) >>> 2;
+        const inbuf = new Uint32Array(arrbuf, 0, inputLength);
+        const outputLength = this.magic.length + 7 + inputLength * 7;
+        const outbuf = new Uint8Array(outputLength);
+        // magic bytes
+        let j = 0;
+        for ( let i = 0; i < this.magic.length; i++ ) {
+            outbuf[j++] = this.magic.charCodeAt(i);
+        }
+        // array size
+        let v = inputLength;
+        do {
+            outbuf[j++] = valToDigit[v & 0b111111];
+            v >>>= 6;
+        } while ( v !== 0 );
+        outbuf[j++] = 0x20 /* ' ' */;
+        // array content
+        for ( let i = 0; i < inputLength; i++ ) {
+            v = inbuf[i];
+            do {
+                outbuf[j++] = valToDigit[v & 0b111111];
+                v >>>= 6;
+            } while ( v !== 0 );
+            outbuf[j++] = 0x20 /* ' ' */;
+        }
+        if ( typeof TextDecoder === 'undefined' ) {
+            return JSON.stringify(
+                Array.from(new Uint32Array(outbuf.buffer, 0, j >>> 2))
+            );
+        }
+        const textDecoder = new TextDecoder();
+        return textDecoder.decode(new Uint8Array(outbuf.buffer, 0, j));
+    },
+
+    decode: function(instr, arrbuf) {
+        if ( instr.charCodeAt(0) === 0x5B /* '[' */ ) {
+            const inbuf = JSON.parse(instr);
+            if ( arrbuf instanceof ArrayBuffer === false ) {
+                return new Uint32Array(inbuf);
+            }
+            const outbuf = new Uint32Array(arrbuf);
+            outbuf.set(inbuf);
+            return outbuf;
+        }
+        if ( instr.startsWith(this.magic) === false ) {
+            throw new Error('Invalid µBlock.base64 encoding');
+        }
+        const inputLength = instr.length;
+        const outputLength = this.decodeSize(instr) >> 2;
+        const outbuf = arrbuf instanceof ArrayBuffer === false
+            ? new Uint32Array(outputLength)
+            : new Uint32Array(arrbuf);
+        let i = instr.indexOf(' ', this.magic.length) + 1;
+        if ( i === -1 ) {
+            throw new Error('Invalid µBlock.base64 encoding');
+        }
+        // array content
+        let j = 0;
+        for (;;) {
+            if ( j === outputLength || i >= inputLength ) { break; }
+            let v = 0, l = 0;
+            for (;;) {
+                const c = instr.charCodeAt(i++);
+                if ( c === 0x20 /* ' ' */ ) { break; }
+                v += digitToVal[c] << l;
+                l += 6;
+            }
+            outbuf[j++] = v;
+        }
+        if ( i < inputLength || j < outputLength ) {
+            throw new Error('Invalid µBlock.base64 encoding');
+        }
+        return outbuf;
+    },
+
+    decodeSize: function(instr) {
+        if ( instr.startsWith(this.magic) === false ) { return 0; }
+        let v = 0, l = 0, i = this.magic.length;
+        for (;;) {
+            const c = instr.charCodeAt(i++);
+            if ( c === 0x20 /* ' ' */ ) { break; }
+            v += digitToVal[c] << l;
+            l += 6;
+        }
+        return v << 2;
+    },
+};
+
+// The dense base64 codec is best for typed buffers which values are
+// more random. For example, buffer contents as a result of compression
+// contain less repetitive values and thus the content is more
+// random-looking.
+
+// TODO: Investigate that in Firefox, creating a new Uint8Array from the
+//       ArrayBuffer fails, the content of the resulting Uint8Array is
+//       non-sensical. WASM-related?
+
+const denseBase64 = {
+    magic: 'DenseBase64_1',
+
+    encode: function(input) {
+        const m = input.length % 3;
+        const n = input.length - m;
+        let outputLength = n / 3 * 4;
+        if ( m !== 0 ) {
+            outputLength += m + 1;
+        }
+        const output = new Uint8Array(outputLength);
+        let j = 0;
+        for ( let i = 0; i < n; i += 3) {
+            const i1 = input[i+0];
+            const i2 = input[i+1];
+            const i3 = input[i+2];
+            output[j+0] = valToDigit[                     i1 >>> 2];
+            output[j+1] = valToDigit[i1 << 4 & 0b110000 | i2 >>> 4];
+            output[j+2] = valToDigit[i2 << 2 & 0b111100 | i3 >>> 6];
+            output[j+3] = valToDigit[i3      & 0b111111           ];
+            j += 4;
+        }
+        if ( m !== 0 ) {
+            const i1 = input[n];
+            output[j+0] = valToDigit[i1 >>> 2];
+            if ( m === 1 ) {    // 1 value
+                output[j+1] = valToDigit[i1 << 4 & 0b110000];
+            } else {            // 2 values
+                const i2 = input[n+1];
+                output[j+1] = valToDigit[i1 << 4 & 0b110000 | i2 >>> 4];
+                output[j+2] = valToDigit[i2 << 2 & 0b111100           ];
+            }
+        }
+        const textDecoder = new TextDecoder();
+        const b64str = textDecoder.decode(output);
+        return this.magic + b64str;
+    },
+
+    decode: function(instr, arrbuf) {
+        if ( instr.startsWith(this.magic) === false ) {
+            throw new Error('Invalid µBlock.denseBase64 encoding');
+        }
+        const outputLength = this.decodeSize(instr);
+        const outbuf = arrbuf instanceof ArrayBuffer === false
+            ? new Uint8Array(outputLength)
+            : new Uint8Array(arrbuf);
+        const inputLength = instr.length - this.magic.length;
+        let i = this.magic.length;
+        let j = 0;
+        const m = inputLength & 3;
+        const n = i + inputLength - m;
+        while ( i < n ) {
+            const i1 = digitToVal[instr.charCodeAt(i+0)];
+            const i2 = digitToVal[instr.charCodeAt(i+1)];
+            const i3 = digitToVal[instr.charCodeAt(i+2)];
+            const i4 = digitToVal[instr.charCodeAt(i+3)];
+            i += 4;
+            outbuf[j+0] = i1 << 2              | i2 >>> 4;
+            outbuf[j+1] = i2 << 4 & 0b11110000 | i3 >>> 2;
+            outbuf[j+2] = i3 << 6 & 0b11000000 | i4;
+            j += 3;
+        }
+        if ( m !== 0 ) {
+            const i1 = digitToVal[instr.charCodeAt(i+0)];
+            const i2 = digitToVal[instr.charCodeAt(i+1)];
+            outbuf[j+0] = i1 << 2 | i2 >>> 4;
+            if ( m === 3 ) {
+                const i3 = digitToVal[instr.charCodeAt(i+2)];
+                outbuf[j+1] = i2 << 4 & 0b11110000 | i3 >>> 2;
+            }
+        }
+        return outbuf;
+    },
+
+    decodeSize: function(instr) {
+        if ( instr.startsWith(this.magic) === false ) { return 0; }
+        const inputLength = instr.length - this.magic.length;
+        const m = inputLength & 3;
+        const n = inputLength - m;
+        let outputLength = (n >>> 2) * 3;
+        if ( m !== 0 ) {
+            outputLength += m - 1;
+        }
+        return outputLength;
+    },
+};
+
+/******************************************************************************/
+
+export { denseBase64, sparseBase64 };