337 lines
11 KiB
JavaScript
337 lines
11 KiB
JavaScript
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"use strict";
|
|
|
|
/* global ExtensionAPI, ExtensionCommon, ExtensionParent, Services, XPCOMUtils */
|
|
|
|
// eslint-disable-next-line mozilla/reject-importGlobalProperties
|
|
XPCOMUtils.defineLazyGlobalGetters(this, ["URL", "ChannelWrapper"]);
|
|
|
|
class AllowList {
|
|
constructor(id) {
|
|
this._id = id;
|
|
}
|
|
|
|
setShims(patterns, notHosts) {
|
|
this._shimPatterns = patterns;
|
|
this._shimMatcher = new MatchPatternSet(patterns || []);
|
|
this._shimNotHosts = notHosts || [];
|
|
return this;
|
|
}
|
|
|
|
setAllows(patterns, hosts) {
|
|
this._allowPatterns = patterns;
|
|
this._allowMatcher = new MatchPatternSet(patterns || []);
|
|
this._allowHosts = hosts || [];
|
|
return this;
|
|
}
|
|
|
|
shims(url, topHost) {
|
|
return (
|
|
this._shimMatcher?.matches(url) && !this._shimNotHosts?.includes(topHost)
|
|
);
|
|
}
|
|
|
|
allows(url, topHost) {
|
|
return (
|
|
this._allowMatcher?.matches(url) && this._allowHosts?.includes(topHost)
|
|
);
|
|
}
|
|
}
|
|
|
|
class Manager {
|
|
constructor() {
|
|
this._allowLists = new Map();
|
|
this._PBModeAllowLists = new Map();
|
|
}
|
|
|
|
_getAllowList(id, isPrivateMode) {
|
|
const activeAllowLists = isPrivateMode
|
|
? this._PBModeAllowLists
|
|
: this._allowLists;
|
|
|
|
if (!activeAllowLists.has(id)) {
|
|
activeAllowLists.set(id, new AllowList(id));
|
|
}
|
|
return activeAllowLists.get(id);
|
|
}
|
|
|
|
_ensureStarted() {
|
|
if (this._classifierObserver) {
|
|
return;
|
|
}
|
|
|
|
this._unblockedChannelIds = new Set();
|
|
this._PBModeUnblockedChannelIds = new Set();
|
|
this._channelClassifier = Cc[
|
|
"@mozilla.org/url-classifier/channel-classifier-service;1"
|
|
].getService(Ci.nsIChannelClassifierService);
|
|
this._classifierObserver = {};
|
|
this._classifierObserver.observe = (subject, topic) => {
|
|
switch (topic) {
|
|
case "http-on-stop-request": {
|
|
const { channelId } = subject.QueryInterface(Ci.nsIIdentChannel);
|
|
const isPrivateMode =
|
|
subject.loadInfo.browsingContext?.originAttributes
|
|
?.privateBrowsingId;
|
|
if (isPrivateMode) {
|
|
this._PBModeUnblockedChannelIds.delete(channelId);
|
|
} else {
|
|
this._unblockedChannelIds.delete(channelId);
|
|
}
|
|
break;
|
|
}
|
|
case "urlclassifier-before-block-channel": {
|
|
const channel = subject.QueryInterface(
|
|
Ci.nsIUrlClassifierBlockedChannel
|
|
);
|
|
const isPrivateMode = subject.isPrivateBrowsing;
|
|
const { channelId, url } = channel;
|
|
let topHost;
|
|
try {
|
|
topHost = new URL(channel.topLevelUrl).hostname;
|
|
} catch (_) {
|
|
return;
|
|
}
|
|
const activeAllowLists = isPrivateMode
|
|
? this._PBModeAllowLists
|
|
: this._allowLists;
|
|
const activeUnblockedChannelIds = isPrivateMode
|
|
? this._PBModeUnblockedChannelIds
|
|
: this._unblockedChannelIds;
|
|
// If anti-tracking webcompat is disabled, we only permit replacing
|
|
// channels, not fully unblocking them.
|
|
if (Manager.ENABLE_WEBCOMPAT) {
|
|
// if any allowlist unblocks the request entirely, we allow it
|
|
for (const allowList of activeAllowLists.values()) {
|
|
if (allowList.allows(url, topHost)) {
|
|
activeUnblockedChannelIds.add(channelId);
|
|
channel.allow();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// otherwise, if any allowlist shims the request we say it's replaced
|
|
for (const allowList of activeAllowLists.values()) {
|
|
if (allowList.shims(url, topHost)) {
|
|
activeUnblockedChannelIds.add(channelId);
|
|
channel.replace();
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
Services.obs.addObserver(this._classifierObserver, "http-on-stop-request");
|
|
this._channelClassifier.addListener(this._classifierObserver);
|
|
}
|
|
|
|
stop() {
|
|
if (!this._classifierObserver) {
|
|
return;
|
|
}
|
|
|
|
Services.obs.removeObserver(
|
|
this._classifierObserver,
|
|
"http-on-stop-request"
|
|
);
|
|
this._channelClassifier.removeListener(this._classifierObserver);
|
|
delete this._channelClassifier;
|
|
delete this._classifierObserver;
|
|
}
|
|
|
|
wasChannelIdUnblocked(channelId, isPrivateMode) {
|
|
const activeUnblockedChannelIds = isPrivateMode
|
|
? this._PBModeUnblockedChannelIds
|
|
: this._unblockedChannelIds;
|
|
return activeUnblockedChannelIds?.has(channelId);
|
|
}
|
|
|
|
allow(allowListId, patterns, isPrivateMode, hosts) {
|
|
this._ensureStarted();
|
|
this._getAllowList(allowListId, isPrivateMode).setAllows(patterns, hosts);
|
|
}
|
|
|
|
shim(allowListId, patterns, isPrivateMode, notHosts) {
|
|
this._ensureStarted();
|
|
this._getAllowList(allowListId, isPrivateMode).setShims(patterns, notHosts);
|
|
}
|
|
|
|
revoke(allowListId) {
|
|
this._allowLists.delete(allowListId);
|
|
this._PBModeAllowLists.delete(allowListId);
|
|
}
|
|
}
|
|
var manager = new Manager();
|
|
|
|
function getChannelId(context, requestId) {
|
|
const wrapper = ChannelWrapper.getRegisteredChannel(
|
|
requestId,
|
|
context.extension.policy,
|
|
context.xulBrowser.frameLoader.remoteTab
|
|
);
|
|
return wrapper?.channel?.QueryInterface(Ci.nsIIdentChannel)?.channelId;
|
|
}
|
|
|
|
var dFPIPrefName = "network.cookie.cookieBehavior";
|
|
var dFPIPbPrefName = "network.cookie.cookieBehavior.pbmode";
|
|
var dFPIStatus;
|
|
function updateDFPIStatus() {
|
|
dFPIStatus = {
|
|
nonPbMode: 5 == Services.prefs.getIntPref(dFPIPrefName),
|
|
pbMode: 5 == Services.prefs.getIntPref(dFPIPbPrefName),
|
|
};
|
|
}
|
|
|
|
this.trackingProtection = class extends ExtensionAPI {
|
|
onShutdown() {
|
|
if (manager) {
|
|
manager.stop();
|
|
}
|
|
Services.prefs.removeObserver(dFPIPrefName, updateDFPIStatus);
|
|
Services.prefs.removeObserver(dFPIPbPrefName, updateDFPIStatus);
|
|
}
|
|
|
|
getAPI(context) {
|
|
const {
|
|
extension: { tabManager },
|
|
} = this;
|
|
const EventManager = ExtensionCommon.EventManager;
|
|
Services.prefs.addObserver(dFPIPrefName, updateDFPIStatus);
|
|
Services.prefs.addObserver(dFPIPbPrefName, updateDFPIStatus);
|
|
updateDFPIStatus();
|
|
|
|
return {
|
|
trackingProtection: {
|
|
onSmartBlockEmbedUnblock: new EventManager({
|
|
context,
|
|
name: "trackingProtection.onSmartBlockEmbedUnblock",
|
|
register: fire => {
|
|
const callback = (subject, topic, data) => {
|
|
// chrome tab id needs to be converted to extension tab id
|
|
let hostname = subject.linkedBrowser.currentURI.host;
|
|
let tabId = tabManager.convert(subject).id;
|
|
fire.sync(tabId, data, hostname);
|
|
};
|
|
Services.obs.addObserver(callback, "smartblock:unblock-embed");
|
|
return () => {
|
|
Services.obs.removeObserver(callback, "smartblock:unblock-embed");
|
|
};
|
|
},
|
|
}).api(),
|
|
onSmartBlockEmbedReblock: new EventManager({
|
|
context,
|
|
name: "trackingProtection.onSmartBlockEmbedReblock",
|
|
register: fire => {
|
|
const callback = (subject, _topic, data) => {
|
|
// chrome tab id needs to be converted to extension tab id
|
|
let hostname = subject.linkedBrowser.currentURI.host;
|
|
let tabId = tabManager.convert(subject).id;
|
|
fire.sync(tabId, data, hostname);
|
|
};
|
|
Services.obs.addObserver(callback, "smartblock:reblock-embed");
|
|
return () => {
|
|
Services.obs.removeObserver(callback, "smartblock:reblock-embed");
|
|
};
|
|
},
|
|
}).api(),
|
|
onPrivateSessionEnd: new EventManager({
|
|
context,
|
|
name: "trackingProtection.onPrivateSessionEnd",
|
|
register: fire => {
|
|
const callback = (_subject, _topic) => {
|
|
fire.sync();
|
|
};
|
|
Services.obs.addObserver(callback, "last-pb-context-exited");
|
|
return () => {
|
|
Services.obs.removeObserver(callback, "last-pb-context-exited");
|
|
};
|
|
},
|
|
}).api(),
|
|
async shim(allowListId, patterns, notHosts) {
|
|
// shim for both PB and non-PB modes
|
|
manager.shim(allowListId, patterns, true, notHosts);
|
|
manager.shim(allowListId, patterns, false, notHosts);
|
|
},
|
|
async allow(allowListId, patterns, isPrivate, hosts) {
|
|
manager.allow(allowListId, patterns, isPrivate, hosts);
|
|
},
|
|
async revoke(allowListId) {
|
|
manager.revoke(allowListId);
|
|
},
|
|
async clearResourceCache() {
|
|
ChromeUtils.clearResourceCache({ target: "content" });
|
|
},
|
|
async wasRequestUnblocked(requestId, isPrivate) {
|
|
if (!manager) {
|
|
return false;
|
|
}
|
|
const channelId = getChannelId(context, requestId);
|
|
if (!channelId) {
|
|
return false;
|
|
}
|
|
return manager.wasChannelIdUnblocked(channelId, isPrivate);
|
|
},
|
|
async isDFPIActive(isPrivate) {
|
|
if (isPrivate) {
|
|
return dFPIStatus.pbMode;
|
|
}
|
|
return dFPIStatus.nonPbMode;
|
|
},
|
|
openProtectionsPanel(tabId) {
|
|
let tab = tabManager.get(tabId);
|
|
if (!tab?.active) {
|
|
// break if tab is not the active tab
|
|
return;
|
|
}
|
|
|
|
let win = tab?.window;
|
|
Services.obs.notifyObservers(
|
|
win.gBrowser.selectedBrowser.browsingContext,
|
|
"smartblock:open-protections-panel"
|
|
);
|
|
},
|
|
incrementSmartblockEmbedShownTelemetry() {
|
|
Glean.securityUiProtectionspopup.smartblockembedsShown.add();
|
|
},
|
|
async getSmartBlockEmbedFluentString(tabId, shimId, websiteHost) {
|
|
let win = tabManager.get(tabId).window;
|
|
let document = win.document;
|
|
|
|
let { gProtectionsHandler } = win.gBrowser.ownerGlobal;
|
|
let { displayName } = gProtectionsHandler.smartblockEmbedInfo.find(
|
|
element => element.shimId == shimId
|
|
);
|
|
|
|
let fluentArgs = [
|
|
{
|
|
id: "smartblock-placeholder-title",
|
|
args: {
|
|
trackername: displayName,
|
|
},
|
|
},
|
|
{
|
|
id: "smartblock-placeholder-desc",
|
|
},
|
|
{
|
|
id: "smartblock-placeholder-button-text",
|
|
args: { websitehost: websiteHost },
|
|
},
|
|
];
|
|
|
|
return document.l10n.formatValues(fluentArgs);
|
|
},
|
|
},
|
|
};
|
|
}
|
|
};
|
|
|
|
XPCOMUtils.defineLazyPreferenceGetter(
|
|
Manager,
|
|
"ENABLE_WEBCOMPAT",
|
|
"privacy.antitracking.enableWebcompat",
|
|
false
|
|
);
|