netwerk/url-classifier/UrlClassifierFeatureEmailTrackingProtection.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "UrlClassifierFeatureEmailTrackingProtection.h"
   8
   9 #include "ChannelClassifierService.h"
  10 #include "mozilla/AntiTrackingUtils.h"
  11 #include "mozilla/net/UrlClassifierCommon.h"
  12 #include "mozilla/StaticPrefs_privacy.h"
  13 #include "mozilla/StaticPtr.h"
  14 #include "nsIChannel.h"
  15 #include "nsILoadContext.h"
  16 #include "nsIHttpChannelInternal.h"
  17 #include "nsIWebProgressListener.h"
  18 #include "nsNetUtil.h"
  19
  20 namespace mozilla::net {
  21
  22 namespace {
  23
  24 #define EMAIL_TRACKING_PROTECTION_FEATURE_NAME "emailtracking-protection"
  25
  26 #define URLCLASSIFIER_EMAIL_TRACKING_BLOCKLIST \
  27   "urlclassifier.features.emailtracking.blocklistTables"
  28 #define URLCLASSIFIER_EMAIL_TRACKING_BLOCKLIST_TEST_ENTRIES \
  29   "urlclassifier.features.emailtracking.blocklistHosts"
  30 #define URLCLASSIFIER_EMAIL_TRACKING_ENTITYLIST \
  31   "urlclassifier.features.emailtracking.allowlistTables"
  32 #define URLCLASSIFIER_EMAIL_TRACKING_ENTITYLIST_TEST_ENTRIES \
  33   "urlclassifier.features.emailtracking.allowlistHosts"
  34 #define URLCLASSIFIER_EMAIL_TRACKING_PROTECTION_EXCEPTION_URLS \
  35   "urlclassifier.features.emailtracking.skipURLs"
  36 #define TABLE_EMAIL_TRACKING_BLOCKLIST_PREF "emailtracking-blocklist-pref"
  37 #define TABLE_EMAIL_TRACKING_ENTITYLIST_PREF "emailtracking-allowlist-pref"
  38
  39 StaticRefPtr<UrlClassifierFeatureEmailTrackingProtection>
  40     gFeatureEmailTrackingProtection;
  41
  42 }  // namespace
  43
  44 UrlClassifierFeatureEmailTrackingProtection::
  45     UrlClassifierFeatureEmailTrackingProtection()
  46     : UrlClassifierFeatureAntiTrackingBase(
  47           nsLiteralCString(EMAIL_TRACKING_PROTECTION_FEATURE_NAME),
  48           nsLiteralCString(URLCLASSIFIER_EMAIL_TRACKING_BLOCKLIST),
  49           nsLiteralCString(URLCLASSIFIER_EMAIL_TRACKING_ENTITYLIST),
  50           nsLiteralCString(URLCLASSIFIER_EMAIL_TRACKING_BLOCKLIST_TEST_ENTRIES),
  51           nsLiteralCString(
  52               URLCLASSIFIER_EMAIL_TRACKING_ENTITYLIST_TEST_ENTRIES),
  53           nsLiteralCString(TABLE_EMAIL_TRACKING_BLOCKLIST_PREF),
  54           nsLiteralCString(TABLE_EMAIL_TRACKING_ENTITYLIST_PREF),
  55           nsLiteralCString(
  56               URLCLASSIFIER_EMAIL_TRACKING_PROTECTION_EXCEPTION_URLS)) {}
  57
  58 /* static */
  59 const char* UrlClassifierFeatureEmailTrackingProtection::Name() {
  60   return EMAIL_TRACKING_PROTECTION_FEATURE_NAME;
  61 }
  62
  63 /* static */
  64 void UrlClassifierFeatureEmailTrackingProtection::MaybeInitialize() {
  65   MOZ_ASSERT(XRE_IsParentProcess());
  66   UC_LOG_LEAK(("UrlClassifierFeatureEmailTrackingProtection::MaybeInitialize"));
  67
  68   if (!gFeatureEmailTrackingProtection) {
  69     gFeatureEmailTrackingProtection =
  70         new UrlClassifierFeatureEmailTrackingProtection();
  71     gFeatureEmailTrackingProtection->InitializePreferences();
  72   }
  73 }
  74
  75 /* static */
  76 void UrlClassifierFeatureEmailTrackingProtection::MaybeShutdown() {
  77   UC_LOG_LEAK(("UrlClassifierFeatureEmailTrackingProtection::MaybeShutdown"));
  78
  79   if (gFeatureEmailTrackingProtection) {
  80     gFeatureEmailTrackingProtection->ShutdownPreferences();
  81     gFeatureEmailTrackingProtection = nullptr;
  82   }
  83 }
  84
  85 /* static */
  86 already_AddRefed<UrlClassifierFeatureEmailTrackingProtection>
  87 UrlClassifierFeatureEmailTrackingProtection::MaybeCreate(nsIChannel* aChannel) {
  88   MOZ_ASSERT(aChannel);
  89
  90   UC_LOG_LEAK(
  91       ("UrlClassifierFeatureEmailTrackingProtection::MaybeCreate - channel %p",
  92        aChannel));
  93
  94   // Check if the email tracking protection is enabled.
  95   if (!StaticPrefs::privacy_trackingprotection_emailtracking_enabled() &&
  96       !(NS_UsePrivateBrowsing(aChannel) &&
  97         StaticPrefs::
  98             privacy_trackingprotection_emailtracking_pbmode_enabled())) {
  99     return nullptr;
 100   }
 101
 102   bool isThirdParty = AntiTrackingUtils::IsThirdPartyChannel(aChannel);
 103   if (!isThirdParty) {
 104     UC_LOG(
 105         ("UrlClassifierFeatureEmailTrackingProtection::MaybeCreate - "
 106          "skipping first party or top-level load for channel %p",
 107          aChannel));
 108     return nullptr;
 109   }
 110
 111   if (!UrlClassifierCommon::ShouldEnableProtectionForChannel(aChannel)) {
 112     return nullptr;
 113   }
 114
 115   MaybeInitialize();
 116   MOZ_ASSERT(gFeatureEmailTrackingProtection);
 117
 118   RefPtr<UrlClassifierFeatureEmailTrackingProtection> self =
 119       gFeatureEmailTrackingProtection;
 120   return self.forget();
 121 }
 122
 123 /* static */
 124 already_AddRefed<nsIUrlClassifierFeature>
 125 UrlClassifierFeatureEmailTrackingProtection::GetIfNameMatches(
 126     const nsACString& aName) {
 127   if (!aName.EqualsLiteral(EMAIL_TRACKING_PROTECTION_FEATURE_NAME)) {
 128     return nullptr;
 129   }
 130
 131   MaybeInitialize();
 132   MOZ_ASSERT(gFeatureEmailTrackingProtection);
 133
 134   RefPtr<UrlClassifierFeatureEmailTrackingProtection> self =
 135       gFeatureEmailTrackingProtection;
 136   return self.forget();
 137 }
 138
 139 NS_IMETHODIMP
 140 UrlClassifierFeatureEmailTrackingProtection::ProcessChannel(
 141     nsIChannel* aChannel, const nsTArray<nsCString>& aList,
 142     const nsTArray<nsCString>& aHashes, bool* aShouldContinue) {
 143   NS_ENSURE_ARG_POINTER(aChannel);
 144   NS_ENSURE_ARG_POINTER(aShouldContinue);
 145
 146   bool isAllowListed = UrlClassifierCommon::IsAllowListed(aChannel);
 147
 148   // This is a blocking feature.
 149   *aShouldContinue = isAllowListed;
 150
 151   if (isAllowListed) {
 152     return NS_OK;
 153   }
 154
 155   nsAutoCString list;
 156   UrlClassifierCommon::TablesToString(aList, list);
 157
 158   ChannelBlockDecision decision =
 159       ChannelClassifierService::OnBeforeBlockChannel(aChannel, mName, list);
 160   if (decision != ChannelBlockDecision::Blocked) {
 161     uint32_t event =
 162         decision == ChannelBlockDecision::Replaced
 163             ? nsIWebProgressListener::STATE_REPLACED_TRACKING_CONTENT
 164             : nsIWebProgressListener::STATE_ALLOWED_TRACKING_CONTENT;
 165
 166     // Need to set aBlocked to True if we replace the Email Tracker with a shim,
 167     //  since the shim is treated as a blocked event
 168     // Note: If we need to account for which kind of tracker was replaced,
 169     //  we need to create a new event type in nsIWebProgressListener
 170     if (event == nsIWebProgressListener::STATE_REPLACED_TRACKING_CONTENT) {
 171       ContentBlockingNotifier::OnEvent(aChannel, event, true);
 172     } else {
 173       ContentBlockingNotifier::OnEvent(aChannel, event, false);
 174     }
 175
 176     *aShouldContinue = true;
 177     return NS_OK;
 178   }
 179
 180   UrlClassifierCommon::SetBlockedContent(aChannel, NS_ERROR_EMAILTRACKING_URI,
 181                                          list, ""_ns, ""_ns);
 182
 183   UC_LOG(
 184       ("UrlClassifierFeatureEmailTrackingProtection::ProcessChannel - "
 185        "cancelling channel %p",
 186        aChannel));
 187
 188   nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(aChannel);
 189   if (httpChannel) {
 190     Unused << httpChannel->CancelByURLClassifier(NS_ERROR_EMAILTRACKING_URI);
 191   } else {
 192     Unused << aChannel->Cancel(NS_ERROR_EMAILTRACKING_URI);
 193   }
 194
 195   return NS_OK;
 196 }
 197
 198 NS_IMETHODIMP
 199 UrlClassifierFeatureEmailTrackingProtection::GetURIByListType(
 200     nsIChannel* aChannel, nsIUrlClassifierFeature::listType aListType,
 201     nsIUrlClassifierFeature::URIType* aURIType, nsIURI** aURI) {
 202   NS_ENSURE_ARG_POINTER(aChannel);
 203   NS_ENSURE_ARG_POINTER(aURIType);
 204   NS_ENSURE_ARG_POINTER(aURI);
 205
 206   if (aListType == nsIUrlClassifierFeature::blocklist) {
 207     *aURIType = nsIUrlClassifierFeature::blocklistURI;
 208     return aChannel->GetURI(aURI);
 209   }
 210
 211   MOZ_ASSERT(aListType == nsIUrlClassifierFeature::entitylist);
 212
 213   *aURIType = nsIUrlClassifierFeature::pairwiseEntitylistURI;
 214   return UrlClassifierCommon::CreatePairwiseEntityListURI(aChannel, aURI);
 215 }
 216
 217 }  // namespace mozilla::net