toolkit/components/antitracking/PartitioningExceptionList.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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "PartitioningExceptionList.h"
   8
   9 #include "AntiTrackingLog.h"
  10 #include "nsContentUtils.h"
  11 #include "nsServiceManagerUtils.h"
  12
  13 #include "mozilla/ClearOnShutdown.h"
  14 #include "mozilla/StaticPtr.h"
  15
  16 namespace mozilla {
  17
  18 namespace {
  19
  20 static constexpr std::array<nsLiteralCString, 2> kSupportedSchemes = {
  21     {"https://"_ns, "http://"_ns}};
  22
  23 StaticRefPtr<PartitioningExceptionList> gPartitioningExceptionList;
  24
  25 }  // namespace
  26
  27 NS_IMPL_ISUPPORTS(PartitioningExceptionList,
  28                   nsIPartitioningExceptionListObserver)
  29
  30 bool PartitioningExceptionList::Check(const nsACString& aFirstPartyOrigin,
  31                                       const nsACString& aThirdPartyOrigin) {
  32   if (!StaticPrefs::privacy_antitracking_enableWebcompat()) {
  33     LOG(("Partition exception list disabled via pref"));
  34     return false;
  35   }
  36
  37   if (aFirstPartyOrigin.IsEmpty() || aFirstPartyOrigin == "null" ||
  38       aThirdPartyOrigin.IsEmpty() || aThirdPartyOrigin == "null") {
  39     return false;
  40   }
  41
  42   LOG(("Check partitioning exception list for url %s and %s",
  43        PromiseFlatCString(aFirstPartyOrigin).get(),
  44        PromiseFlatCString(aThirdPartyOrigin).get()));
  45
  46   for (PartitionExceptionListEntry& entry : GetOrCreate()->mExceptionList) {
  47     if (OriginMatchesPattern(aFirstPartyOrigin, entry.mFirstParty) &&
  48         OriginMatchesPattern(aThirdPartyOrigin, entry.mThirdParty)) {
  49       LOG(("Found partitioning exception list entry for %s and %s",
  50            PromiseFlatCString(aFirstPartyOrigin).get(),
  51            PromiseFlatCString(aThirdPartyOrigin).get()));
  52
  53       return true;
  54     }
  55   }
  56
  57   return false;
  58 }
  59
  60 PartitioningExceptionList* PartitioningExceptionList::GetOrCreate() {
  61   if (!gPartitioningExceptionList) {
  62     gPartitioningExceptionList = new PartitioningExceptionList();
  63     gPartitioningExceptionList->Init();
  64
  65     RunOnShutdown([&] {
  66       gPartitioningExceptionList->Shutdown();
  67       gPartitioningExceptionList = nullptr;
  68     });
  69   }
  70
  71   return gPartitioningExceptionList;
  72 }
  73
  74 nsresult PartitioningExceptionList::Init() {
  75   mService =
  76       do_GetService("@mozilla.org/partitioning/exception-list-service;1");
  77   if (NS_WARN_IF(!mService)) {
  78     return NS_ERROR_FAILURE;
  79   }
  80
  81   mService->RegisterAndRunExceptionListObserver(this);
  82   return NS_OK;
  83 }
  84
  85 void PartitioningExceptionList::Shutdown() {
  86   if (mService) {
  87     mService->UnregisterExceptionListObserver(this);
  88     mService = nullptr;
  89   }
  90
  91   mExceptionList.Clear();
  92 }
  93
  94 NS_IMETHODIMP
  95 PartitioningExceptionList::OnExceptionListUpdate(const nsACString& aList) {
  96   mExceptionList.Clear();
  97
  98   nsresult rv;
  99   for (const nsACString& item : aList.Split(';')) {
 100     auto origins = item.Split(',');
 101     auto originsIt = origins.begin();
 102
 103     if (originsIt == origins.end()) {
 104       LOG(("Ignoring empty exception entry"));
 105       continue;
 106     }
 107
 108     PartitionExceptionListEntry entry;
 109
 110     rv = GetExceptionListPattern(*originsIt, entry.mFirstParty);
 111     if (NS_WARN_IF(NS_FAILED(rv))) {
 112       continue;
 113     }
 114
 115     ++originsIt;
 116
 117     if (originsIt == origins.end()) {
 118       LOG(("Ignoring incomplete exception entry"));
 119       continue;
 120     }
 121
 122     rv = GetExceptionListPattern(*originsIt, entry.mThirdParty);
 123     if (NS_WARN_IF(NS_FAILED(rv))) {
 124       continue;
 125     }
 126
 127     if (entry.mFirstParty.mSuffix == "*" && entry.mThirdParty.mSuffix == "*") {
 128       LOG(("Ignoring *,* exception entry"));
 129       continue;
 130     }
 131
 132     LOG(("onExceptionListUpdate: %s%s - %s%s", entry.mFirstParty.mScheme.get(),
 133          entry.mFirstParty.mSuffix.get(), entry.mThirdParty.mScheme.get(),
 134          entry.mThirdParty.mSuffix.get()));
 135
 136     mExceptionList.AppendElement(entry);
 137   }
 138
 139   return NS_OK;
 140 }
 141
 142 nsresult PartitioningExceptionList::GetSchemeFromOrigin(
 143     const nsACString& aOrigin, nsACString& aScheme,
 144     nsACString& aOriginNoScheme) {
 145   NS_ENSURE_FALSE(aOrigin.IsEmpty(), NS_ERROR_INVALID_ARG);
 146
 147   for (const auto& scheme : kSupportedSchemes) {
 148     if (aOrigin.Length() <= scheme.Length() ||
 149         !StringBeginsWith(aOrigin, scheme)) {
 150       continue;
 151     }
 152     aScheme = Substring(aOrigin, 0, scheme.Length());
 153     aOriginNoScheme = Substring(aOrigin, scheme.Length());
 154     return NS_OK;
 155   }
 156
 157   return NS_ERROR_FAILURE;
 158 }
 159
 160 bool PartitioningExceptionList::OriginMatchesPattern(
 161     const nsACString& aOrigin, const PartitionExceptionListPattern& aPattern) {
 162   if (NS_WARN_IF(aOrigin.IsEmpty())) {
 163     return false;
 164   }
 165
 166   if (aPattern.mSuffix == "*") {
 167     return true;
 168   }
 169
 170   nsAutoCString scheme, originNoScheme;
 171   nsresult rv = GetSchemeFromOrigin(aOrigin, scheme, originNoScheme);
 172   NS_ENSURE_SUCCESS(rv, false);
 173
 174   // Always strict match scheme.
 175   if (scheme != aPattern.mScheme) {
 176     return false;
 177   }
 178
 179   if (!aPattern.mIsWildCard) {
 180     // aPattern is not a wildcard, match strict.
 181     return originNoScheme == aPattern.mSuffix;
 182   }
 183
 184   // For wildcard patterns, check if origin suffix matches pattern suffix.
 185   return StringEndsWith(originNoScheme, aPattern.mSuffix);
 186 }
 187
 188 // Parses a string with an origin or an origin-pattern into a
 189 // PartitionExceptionListPattern.
 190 nsresult PartitioningExceptionList::GetExceptionListPattern(
 191     const nsACString& aOriginPattern, PartitionExceptionListPattern& aPattern) {
 192   NS_ENSURE_FALSE(aOriginPattern.IsEmpty(), NS_ERROR_INVALID_ARG);
 193
 194   if (aOriginPattern == "*") {
 195     aPattern.mIsWildCard = true;
 196     aPattern.mSuffix = "*";
 197
 198     return NS_OK;
 199   }
 200
 201   nsAutoCString originPatternNoScheme;
 202   nsresult rv = GetSchemeFromOrigin(aOriginPattern, aPattern.mScheme,
 203                                     originPatternNoScheme);
 204   NS_ENSURE_SUCCESS(rv, rv);
 205
 206   if (StringBeginsWith(originPatternNoScheme, "*"_ns)) {
 207     NS_ENSURE_TRUE(originPatternNoScheme.Length() > 2, NS_ERROR_INVALID_ARG);
 208
 209     aPattern.mIsWildCard = true;
 210     aPattern.mSuffix = Substring(originPatternNoScheme, 1);
 211
 212     return NS_OK;
 213   }
 214
 215   aPattern.mIsWildCard = false;
 216   aPattern.mSuffix = originPatternNoScheme;
 217
 218   return NS_OK;
 219 }
 220
 221 }  // namespace mozilla