Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-08 02:14:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1584479 - Part 1: Add flag for blocked social cookies in the content blocking log. r=Ehsan,droeh

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D47427

--HG--
extra : moz-landing-system : lando
This commit is contained in:
Nihanth Subramanya 2019-11-01 23:24:25 +00:00
parent f34ffda7e2
commit 2164478f1e
28 changed files with 286 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dom/base/ContentBlockingLog.cpp
View File

@ -167,8 +167,10 @@ void ContentBlockingLog::ReportOrigins() {
}
for (const auto& logEntry : Reversed(originEntry.mData->mLogs)) {
if (logEntry.mType !=
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
if ((logEntry.mType !=
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER &&
logEntry.mType !=
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER) ||
logEntry.mTrackingFullHashes.IsEmpty()) {
continue;
}

3
dom/base/ContentBlockingLog.h
View File

@ -84,7 +84,8 @@ class ContentBlockingLog final {
const Maybe<AntiTrackingCommon::StorageAccessGrantedReason>& aReason,
const nsTArray<nsCString>& aTrackingFullHashes) {
DebugOnly<bool> isCookiesBlockedTracker =
aType == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER;
aType == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aType == nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
MOZ_ASSERT_IF(aBlocked, aReason.isNothing());
MOZ_ASSERT_IF(!isCookiesBlockedTracker, aReason.isNothing());
MOZ_ASSERT_IF(isCookiesBlockedTracker && !aBlocked, aReason.isSome());

21
dom/base/Document.h
View File

@ -1165,6 +1165,14 @@ class Document : public nsINode,
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER);
}
/**
* Get social tracking cookies blocked flag for this document.
*/
bool GetHasSocialTrackingCookiesBlocked() {
return mContentBlockingLog.HasBlockedAnyOfType(
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER);
}
/**
* Get third-party cookies blocked flag for this document.
*/
@ -1246,6 +1254,19 @@ class Document : public nsINode,
aHasTrackingCookiesBlocked, aReason, aTrackingFullHashes);
}
/**
* Set the social tracking cookies blocked flag for this document.
*/
void SetHasSocialTrackingCookiesBlocked(
bool aHasSocialTrackingCookiesBlocked, const nsACString& aOriginBlocked,
const Maybe<AntiTrackingCommon::StorageAccessGrantedReason>& aReason,
const nsTArray<nsCString>& aTrackingFullHashes) {
RecordContentBlockingLog(
aOriginBlocked,
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER,
aHasSocialTrackingCookiesBlocked, aReason, aTrackingFullHashes);
}
/**
* Set the third-party cookies blocked flag for this document.
*/

3
dom/base/nsGlobalWindowInner.cpp
View File

@ -4478,7 +4478,8 @@ Storage* nsGlobalWindowInner::GetSessionStorage(ErrorResult& aError) {
// 3. Tracking protection (BEHAVIOR_REJECT_TRACKER) is in effect and
// IsThirdPartyTrackingResourceWindow() returned true and there wasn't a
// permission that allows it. This will return ePartitionTrackersOrDeny with
// a reason of STATE_COOKIES_BLOCKED_TRACKER.
// a reason of STATE_COOKIES_BLOCKED_TRACKER or
// STATE_COOKIES_BLOCKED_SOCIALTRACKER.
//
// In the 1st case, the user has explicitly indicated that they don't want
// to allow any storage to the origin or all origins and so we throw an

16
dom/base/nsGlobalWindowOuter.cpp
View File

@ -5390,7 +5390,8 @@ void nsGlobalWindowOuter::NotifyContentBlockingEvent(
aReason) {
MOZ_ASSERT(aURIHint);
DebugOnly<bool> isCookiesBlockedTracker =
aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER;
aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aEvent == nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
MOZ_ASSERT_IF(aBlocked, aReason.isNothing());
MOZ_ASSERT_IF(!isCookiesBlockedTracker, aReason.isNothing());
MOZ_ASSERT_IF(isCookiesBlockedTracker && !aBlocked, aReason.isSome());
@ -5500,6 +5501,19 @@ void nsGlobalWindowOuter::NotifyContentBlockingEvent(
if (!aBlocked) {
unblocked = !doc->GetHasTrackingCookiesBlocked();
}
} else if (aEvent == nsIWebProgressListener::
STATE_COOKIES_BLOCKED_SOCIALTRACKER) {
nsTArray<nsCString> trackingFullHashes;
if (trackingChannel) {
Unused << trackingChannel->GetMatchedTrackingFullHashes(
trackingFullHashes);
}
doc->SetHasSocialTrackingCookiesBlocked(aBlocked, origin, aReason,
trackingFullHashes);
if (!aBlocked) {
unblocked = !doc->GetHasSocialTrackingCookiesBlocked();
}
} else if (aEvent ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL) {
doc->SetHasAllCookiesBlocked(aBlocked, origin);

6
dom/ipc/RemoteWebProgressRequest.cpp
View File

@ -238,6 +238,12 @@ RemoteWebProgressRequest::IsThirdPartyTrackingResource(
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
RemoteWebProgressRequest::IsSocialTrackingResource(
bool* aIsSocialTrackingResource) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
RemoteWebProgressRequest::GetClassificationFlags(
uint32_t* aClassificationFlags) {

1
mobile/android/geckoview/api.txt
View File

@ -274,6 +274,7 @@ package org.mozilla.geckoview {
field public static final int COOKIES_BLOCKED_ALL = 1073741824;
field public static final int COOKIES_BLOCKED_BY_PERMISSION = 268435456;
field public static final int COOKIES_BLOCKED_FOREIGN = 128;
field public static final int COOKIES_BLOCKED_SOCIALTRACKER = 16777216;
field public static final int COOKIES_BLOCKED_TRACKER = 536870912;
field public static final int COOKIES_LOADED = 32768;
field public static final int COOKIES_LOADED_SOCIALTRACKER = 524288;

3
mobile/android/geckoview/src/main/java/org/mozilla/geckoview/ContentBlocking.java
View File

@ -827,6 +827,7 @@ public class ContentBlocking {
private static final long STATE_COOKIES_LOADED_TRACKER = 0x40000L;
private static final long STATE_COOKIES_LOADED_SOCIALTRACKER = 0x80000L;
private static final long STATE_COOKIES_BLOCKED_TRACKER = 0x20000000L;
private static final long STATE_COOKIES_BLOCKED_SOCIALTRACKER = 0x01000000L;
private static final long STATE_COOKIES_BLOCKED_ALL = 0x40000000L;
private static final long STATE_COOKIES_BLOCKED_FOREIGN = 0x80L;
@ -834,6 +835,7 @@ public class ContentBlocking {
return
(geckoCat &
(STATE_COOKIES_BLOCKED_TRACKER |
STATE_COOKIES_BLOCKED_SOCIALTRACKER |
STATE_COOKIES_BLOCKED_ALL |
STATE_COOKIES_BLOCKED_FOREIGN))
!= 0;
@ -852,6 +854,7 @@ public class ContentBlocking {
// If we receive STATE_COOKIES_LOADED_{SOCIAL,}TRACKER we know that this
// setting would block this cookie.
if ((geckoCat & (STATE_COOKIES_BLOCKED_TRACKER |
STATE_COOKIES_BLOCKED_SOCIALTRACKER |
STATE_COOKIES_LOADED_TRACKER |
STATE_COOKIES_LOADED_SOCIALTRACKER)) != 0) {
return CookieBehavior.ACCEPT_NON_TRACKERS;

12
mobile/android/geckoview/src/main/java/org/mozilla/geckoview/ContentBlockingController.java
View File

@ -275,6 +275,12 @@ public class ContentBlockingController {
*/
public static final int COOKIES_BLOCKED_TRACKER = 0x20000000;
/**
* Rejected because the resource is a tracker from a social origin and
* cookie policy doesn't allow its loading.
*/
public static final int COOKIES_BLOCKED_SOCIALTRACKER = 0x01000000;
/**
* Rejected because cookie policy blocks all cookies.
*/
@ -320,9 +326,9 @@ public class ContentBlockingController {
Event.BLOCKED_UNSAFE_CONTENT, Event.COOKIES_LOADED,
Event.COOKIES_LOADED_TRACKER, Event.COOKIES_LOADED_SOCIALTRACKER,
Event.COOKIES_BLOCKED_BY_PERMISSION, Event.COOKIES_BLOCKED_TRACKER,
Event.COOKIES_BLOCKED_ALL, Event.COOKIES_PARTITIONED_FOREIGN,
Event.COOKIES_BLOCKED_FOREIGN, Event.BLOCKED_SOCIALTRACKING_CONTENT,
Event.LOADED_SOCIALTRACKING_CONTENT })
Event.COOKIES_BLOCKED_SOCIALTRACKER, Event.COOKIES_BLOCKED_ALL,
Event.COOKIES_PARTITIONED_FOREIGN, Event.COOKIES_BLOCKED_FOREIGN,
Event.BLOCKED_SOCIALTRACKING_CONTENT, Event.LOADED_SOCIALTRACKING_CONTENT })
/* package */ @interface LogEvent {}
/**

4
mobile/android/geckoview/src/main/java/org/mozilla/geckoview/doc-files/CHANGELOG.md
View File

@ -14,6 +14,8 @@ exclude: true
⚠️ breaking change
## v71
- Added a content blocking flag for blocked social cookies to [`ContentBlocking`][70.17].
([bug 1584479]({{bugzilla}}1584479))
- Added [`onBooleanScalar`][71.1], [`onLongScalar`][71.2],
[`onStringScalar`][71.3] to [`RuntimeTelemetry.Delegate`][70.12] to support
scalars in streaming telemetry. ⚠️ As part of this change,
@ -402,4 +404,4 @@ exclude: true
[65.24]: {{javadoc_uri}}/CrashReporter.html#sendCrashReport-android.content.Context-android.os.Bundle-java.lang.String-
[65.25]: {{javadoc_uri}}/GeckoResult.html
[api-version]: 6a71a9226b15eb40fb47f5da7400915f29fb4986
[api-version]: 950568652bacb957f8af2a3cd68b4408eccbf78d

36
netwerk/base/nsIClassifiedChannel.idl
View File

@ -151,7 +151,8 @@ interface nsIClassifiedChannel : nsISupports
* tracker.
* This is a helper attribute which returns the same value of
* (classificationFlags & CLASSIFIED_ANY_BASIC_TRACKING) or
* (classificationFlags & CLASSIFIED_ANY_STRICT_TRACKING)
* (classificationFlags & CLASSIFIED_ANY_STRICT_TRACKING) or
* (classificationFlags & CLASSIFIED_ANY_SOCIAL_TRACKING)
*
* Note that top-level channels could be marked as tracking
* resource. In order to identify third-party tracking resources
@ -171,13 +172,14 @@ interface nsIClassifiedChannel : nsISupports
%}
/**
* Returns the classification flags if the channel has been processed by
* URL-Classifier features and is considered third-party with the top
* window URI.
* Returns true if the channel has been processed by URL-Classifier features
* and is considered third-party with the top window URI, and if it has loaded
* a resource that is classified as a tracker.
*
* This is a helper attribute which returns the same value of
* (thirdPartyClassificationFlags & CLASSIFIED_ANY_BASIC_TRACKING) or
* (thirdPartyClassificationFlags & CLASSIFIED_ANY_STRICT_TRACKING)
* (thirdPartyClassificationFlags & CLASSIFIED_ANY_STRICT_TRACKING) or
* (thirdPartyClassificationFlags & CLASSIFIED_ANY_SOCIAL_TRACKING)
*/
boolean isThirdPartyTrackingResource();
@ -191,4 +193,28 @@ interface nsIClassifiedChannel : nsISupports
return false;
}
%}
/**
* Returns true if the channel has loaded a resource that is classified as
* a social tracker.
*
* This is a helper attribute which returns the same value of
* (classificationFlags & CLASSIFIED_ANY_SOCIAL_TRACKING)
*
* Note that top-level channels could be marked as tracking
* resources. In order to identify third-party social tracking resources
* specifically, check the flags manually or add a new helper here.
*/
boolean isSocialTrackingResource();
%{ C++
inline bool IsSocialTrackingResource()
{
bool value = false;
if (NS_SUCCEEDED(IsSocialTrackingResource(&value)) && value) {
return true;
}
return false;
}
%}
};

25
netwerk/cookie/CookieServiceChild.cpp
View File

@ -136,6 +136,7 @@ void CookieServiceChild::TrackCookieLoad(nsIChannel* aChannel) {
bool isForeign = false;
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool firstPartyStorageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIURI> uri;
@ -148,6 +149,7 @@ void CookieServiceChild::TrackCookieLoad(nsIChannel* aChannel) {
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
// foreign cookie behavior mode.
@ -172,6 +174,7 @@ void CookieServiceChild::TrackCookieLoad(nsIChannel* aChannel) {
bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel);
bool isSameSiteForeign = NS_IsSameSiteForeign(aChannel, uri);
SendPrepareCookieList(uriParams, isForeign, isTrackingResource,
isSocialTrackingResource,
firstPartyStorageAccessGranted, rejectedReason,
isSafeTopLevelNav, isSameSiteForeign, attrs);
}
@ -265,9 +268,9 @@ void CookieServiceChild::PrefChanged(nsIPrefBranch* aPrefBranch) {
void CookieServiceChild::GetCookieStringFromCookieHashTable(
nsIURI* aHostURI, bool aIsForeign, bool aIsTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign, nsIChannel* aChannel,
nsACString& aCookieString) {
bool aIsSocialTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, bool aIsSafeTopLevelNav, bool aIsSameSiteForeign,
nsIChannel* aChannel, nsACString& aCookieString) {
nsCOMPtr<nsIEffectiveTLDService> TLDService =
do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID);
NS_ASSERTION(TLDService, "Can't get TLDService");
@ -304,7 +307,7 @@ void CookieServiceChild::GetCookieStringFromCookieHashTable(
CookieStatus cookieStatus = nsCookieService::CheckPrefs(
cookieSettings, aHostURI, aIsForeign, aIsTrackingResource,
aFirstPartyStorageAccessGranted, VoidCString(),
aIsSocialTrackingResource, aFirstPartyStorageAccessGranted, VoidCString(),
CountCookiesFromHashTable(baseDomain, attrs), attrs, &aRejectedReason);
if (cookieStatus != STATUS_ACCEPTED &&
@ -471,12 +474,14 @@ nsresult CookieServiceChild::GetCookieStringInternal(
}
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool firstPartyStorageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
// foreign cookie behavior mode.
@ -490,9 +495,9 @@ nsresult CookieServiceChild::GetCookieStringInternal(
bool isSameSiteForeign = NS_IsSameSiteForeign(aChannel, aHostURI);
GetCookieStringFromCookieHashTable(
aHostURI, isForeign, isTrackingResource, firstPartyStorageAccessGranted,
rejectedReason, isSafeTopLevelNav, isSameSiteForeign, aChannel,
aCookieString);
aHostURI, isForeign, isTrackingResource, isSocialTrackingResource,
firstPartyStorageAccessGranted, rejectedReason, isSafeTopLevelNav,
isSameSiteForeign, aChannel, aCookieString);
return NS_OK;
}
@ -516,12 +521,14 @@ nsresult CookieServiceChild::SetCookieStringInternal(
}
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool firstPartyStorageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
// foreign cookie behavior mode.
@ -556,7 +563,7 @@ nsresult CookieServiceChild::SetCookieStringInternal(
// Asynchronously call the parent.
if (CanSend()) {
SendSetCookieString(hostURIParams, channelURIParams, optionalLoadInfoArgs,
isForeign, isTrackingResource,
isForeign, isTrackingResource, isSocialTrackingResource,
firstPartyStorageAccessGranted, rejectedReason, attrs,
cookieString, nsCString(aServerTime), aFromHttp);
}
@ -571,7 +578,7 @@ nsresult CookieServiceChild::SetCookieStringInternal(
CookieStatus cookieStatus = nsCookieService::CheckPrefs(
cookieSettings, aHostURI, isForeign, isTrackingResource,
firstPartyStorageAccessGranted, aCookieString,
isSocialTrackingResource, firstPartyStorageAccessGranted, aCookieString,
CountCookiesFromHashTable(baseDomain, attrs), attrs, &rejectedReason);
if (cookieStatus != STATUS_ACCEPTED &&

6
netwerk/cookie/CookieServiceChild.h
View File

@ -61,9 +61,9 @@ class CookieServiceChild : public PCookieServiceChild,
void GetCookieStringFromCookieHashTable(
nsIURI* aHostURI, bool aIsForeign, bool aIsTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign, nsIChannel* aChannel,
nsACString& aCookieString);
bool aIsSocialTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, bool aIsSafeTopLevelNav,
bool aIsSameSiteForeign, nsIChannel* aChannel, nsACString& aCookieString);
nsresult SetCookieStringInternal(nsIURI* aHostURI, nsIChannel* aChannel,
const nsACString& aCookieString,

25
netwerk/cookie/CookieServiceParent.cpp
View File

@ -120,12 +120,14 @@ void CookieServiceParent::TrackCookieLoad(nsIChannel* aChannel) {
thirdPartyUtil->IsThirdPartyChannel(aChannel, uri, &isForeign);
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool storageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
// foreign cookie behavior mode.
@ -136,10 +138,10 @@ void CookieServiceParent::TrackCookieLoad(nsIChannel* aChannel) {
}
nsTArray<nsCookie*> foundCookieList;
mCookieService->GetCookiesForURI(uri, aChannel, isForeign, isTrackingResource,
storageAccessGranted, rejectedReason,
isSafeTopLevelNav, aIsSameSiteForeign, false,
attrs, foundCookieList);
mCookieService->GetCookiesForURI(
uri, aChannel, isForeign, isTrackingResource, isSocialTrackingResource,
storageAccessGranted, rejectedReason, isSafeTopLevelNav,
aIsSameSiteForeign, false, attrs, foundCookieList);
nsTArray<CookieStruct> matchingCookiesList;
SerialializeCookieList(foundCookieList, matchingCookiesList, uri);
Unused << SendTrackCookiesLoad(matchingCookiesList, attrs);
@ -161,7 +163,7 @@ void CookieServiceParent::SerialializeCookieList(
mozilla::ipc::IPCResult CookieServiceParent::RecvPrepareCookieList(
const URIParams& aHost, const bool& aIsForeign,
const bool& aIsTrackingResource,
const bool& aIsTrackingResource, const bool& aIsSocialTrackingResource,
const bool& aFirstPartyStorageAccessGranted,
const uint32_t& aRejectedReason, const bool& aIsSafeTopLevelNav,
const bool& aIsSameSiteForeign, const OriginAttributes& aAttrs) {
@ -174,8 +176,9 @@ mozilla::ipc::IPCResult CookieServiceParent::RecvPrepareCookieList(
// child process already does the necessary reporting in this case for us.
mCookieService->GetCookiesForURI(
hostURI, nullptr, aIsForeign, aIsTrackingResource,
aFirstPartyStorageAccessGranted, aRejectedReason, aIsSafeTopLevelNav,
aIsSameSiteForeign, false, aAttrs, foundCookieList);
aIsSocialTrackingResource, aFirstPartyStorageAccessGranted,
aRejectedReason, aIsSafeTopLevelNav, aIsSameSiteForeign, false, aAttrs,
foundCookieList);
nsTArray<CookieStruct> matchingCookiesList;
SerialializeCookieList(foundCookieList, matchingCookiesList, hostURI);
Unused << SendTrackCookiesLoad(matchingCookiesList, aAttrs);
@ -190,7 +193,7 @@ void CookieServiceParent::ActorDestroy(ActorDestroyReason aWhy) {
mozilla::ipc::IPCResult CookieServiceParent::RecvSetCookieString(
const URIParams& aHost, const Maybe<URIParams>& aChannelURI,
const Maybe<LoadInfoArgs>& aLoadInfoArgs, const bool& aIsForeign,
const bool& aIsTrackingResource,
const bool& aIsTrackingResource, const bool& aIsSocialTrackingResource,
const bool& aFirstPartyStorageAccessGranted,
const uint32_t& aRejectedReason, const OriginAttributes& aAttrs,
const nsCString& aCookieString, const nsCString& aServerTime,
@ -230,9 +233,9 @@ mozilla::ipc::IPCResult CookieServiceParent::RecvSetCookieString(
// we don't send it back to the same content process.
mProcessingCookie = true;
mCookieService->SetCookieStringInternal(
hostURI, aIsForeign, aIsTrackingResource, aFirstPartyStorageAccessGranted,
aRejectedReason, cookieString, aServerTime, aFromHttp, aAttrs,
dummyChannel);
hostURI, aIsForeign, aIsTrackingResource, aIsSocialTrackingResource,
aFirstPartyStorageAccessGranted, aRejectedReason, cookieString,
aServerTime, aFromHttp, aAttrs, dummyChannel);
mProcessingCookie = false;
return IPC_OK();
}

4
netwerk/cookie/CookieServiceParent.h
View File

@ -47,7 +47,7 @@ class CookieServiceParent : public PCookieServiceParent {
mozilla::ipc::IPCResult RecvSetCookieString(
const URIParams& aHost, const Maybe<URIParams>& aChannelURI,
const Maybe<LoadInfoArgs>& aLoadInfoArgs, const bool& aIsForeign,
const bool& aIsTrackingResource,
const bool& aIsTrackingResource, const bool& aIsSocialTrackingResource,
const bool& aFirstPartyStorageAccessGranted,
const uint32_t& aRejectedReason, const OriginAttributes& aAttrs,
const nsCString& aCookieString, const nsCString& aServerTime,
@ -55,7 +55,7 @@ class CookieServiceParent : public PCookieServiceParent {
mozilla::ipc::IPCResult RecvPrepareCookieList(
const URIParams& aHost, const bool& aIsForeign,
const bool& aIsTrackingResource,
const bool& aIsTrackingResource, const bool& aIsSocialTrackingResource,
const bool& aFirstPartyStorageAccessGranted,
const uint32_t& aRejectedReason, const bool& aIsSafeTopLevelNav,
const bool& aIsSameSiteForeign, const OriginAttributes& aAttrs);

2
netwerk/cookie/PCookieService.ipdl
View File

@ -74,6 +74,7 @@ parent:
LoadInfoArgs? loadInfoArgs,
bool isForeign,
bool isTrackingResource,
bool isSocialTrackingResource,
bool firstPartyStorageAccessGranted,
uint32_t rejectedReason,
OriginAttributes aStoragePrincipalAttrs,
@ -84,6 +85,7 @@ parent:
async PrepareCookieList(URIParams host,
bool isForeign,
bool isTrackingResource,
bool isSocialTrackingResource,
bool firstPartyStorageAccessGranted,
uint32_t rejectedReason,
bool isSafeTopLevelNav,

68
netwerk/cookie/nsCookieService.cpp
View File

@ -2011,12 +2011,14 @@ nsresult nsCookieService::GetCookieStringCommon(nsIURI* aHostURI,
}
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool firstPartyStorageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
@ -2035,10 +2037,10 @@ nsresult nsCookieService::GetCookieStringCommon(nsIURI* aHostURI,
bool isSafeTopLevelNav = NS_IsSafeTopLevelNav(aChannel);
bool isSameSiteForeign = NS_IsSameSiteForeign(aChannel, aHostURI);
GetCookieStringInternal(aHostURI, aChannel, isForeign, isTrackingResource,
firstPartyStorageAccessGranted, rejectedReason,
isSafeTopLevelNav, isSameSiteForeign, aHttpBound,
attrs, aCookie);
GetCookieStringInternal(
aHostURI, aChannel, isForeign, isTrackingResource,
isSocialTrackingResource, firstPartyStorageAccessGranted, rejectedReason,
isSafeTopLevelNav, isSameSiteForeign, aHttpBound, attrs, aCookie);
return NS_OK;
}
@ -2134,12 +2136,14 @@ nsresult nsCookieService::SetCookieStringCommon(nsIURI* aHostURI,
}
bool isTrackingResource = false;
bool isSocialTrackingResource = false;
bool firstPartyStorageAccessGranted = false;
uint32_t rejectedReason = 0;
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (classifiedChannel) {
isTrackingResource = classifiedChannel->IsTrackingResource();
isSocialTrackingResource = classifiedChannel->IsSocialTrackingResource();
// Check first-party storage access even for non-tracking resources, since
// we will need the result when computing the access rights for the reject
@ -2158,15 +2162,17 @@ nsresult nsCookieService::SetCookieStringCommon(nsIURI* aHostURI,
nsCString cookieString(aCookieHeader);
SetCookieStringInternal(
aHostURI, isForeign, isTrackingResource, firstPartyStorageAccessGranted,
rejectedReason, cookieString, aServerTime, aFromHttp, attrs, aChannel);
aHostURI, isForeign, isTrackingResource, isSocialTrackingResource,
firstPartyStorageAccessGranted, rejectedReason, cookieString, aServerTime,
aFromHttp, attrs, aChannel);
return NS_OK;
}
void nsCookieService::SetCookieStringInternal(
nsIURI* aHostURI, bool aIsForeign, bool aIsTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
nsCString& aCookieHeader, const nsACString& aServerTime, bool aFromHttp,
bool aIsSocialTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, nsCString& aCookieHeader,
const nsACString& aServerTime, bool aFromHttp,
const OriginAttributes& aOriginAttrs, nsIChannel* aChannel) {
NS_ASSERTION(aHostURI, "null host!");
@ -2205,9 +2211,9 @@ void nsCookieService::SetCookieStringInternal(
nsAutoCString hostFromURI;
aHostURI->GetHost(hostFromURI);
CountCookiesFromHost(hostFromURI, &priorCookieCount);
CookieStatus cookieStatus =
CheckPrefs(cookieSettings, aHostURI, aIsForeign, aIsTrackingResource,
aFirstPartyStorageAccessGranted, aCookieHeader,
CookieStatus cookieStatus = CheckPrefs(
cookieSettings, aHostURI, aIsForeign, aIsTrackingResource,
aIsSocialTrackingResource, aFirstPartyStorageAccessGranted, aCookieHeader,
priorCookieCount, aOriginAttrs, &rejectedReason);
MOZ_ASSERT_IF(rejectedReason, cookieStatus == STATUS_REJECTED);
@ -2966,10 +2972,10 @@ bool nsCookieService::PathMatches(nsCookie* aCookie, const nsACString& aPath) {
void nsCookieService::GetCookiesForURI(
nsIURI* aHostURI, nsIChannel* aChannel, bool aIsForeign,
bool aIsTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, bool aIsSafeTopLevelNav, bool aIsSameSiteForeign,
bool aHttpBound, const OriginAttributes& aOriginAttrs,
nsTArray<nsCookie*>& aCookieList) {
bool aIsTrackingResource, bool aIsSocialTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign, bool aHttpBound,
const OriginAttributes& aOriginAttrs, nsTArray<nsCookie*>& aCookieList) {
NS_ASSERTION(aHostURI, "null host!");
if (!mDBState) {
@ -3006,9 +3012,9 @@ void nsCookieService::GetCookiesForURI(
uint32_t rejectedReason = aRejectedReason;
uint32_t priorCookieCount = 0;
CountCookiesFromHost(hostFromURI, &priorCookieCount);
CookieStatus cookieStatus =
CheckPrefs(cookieSettings, aHostURI, aIsForeign, aIsTrackingResource,
aFirstPartyStorageAccessGranted, VoidCString(),
CookieStatus cookieStatus = CheckPrefs(
cookieSettings, aHostURI, aIsForeign, aIsTrackingResource,
aIsSocialTrackingResource, aFirstPartyStorageAccessGranted, VoidCString(),
priorCookieCount, aOriginAttrs, &rejectedReason);
MOZ_ASSERT_IF(rejectedReason, cookieStatus == STATUS_REJECTED);
@ -3141,15 +3147,15 @@ void nsCookieService::GetCookiesForURI(
void nsCookieService::GetCookieStringInternal(
nsIURI* aHostURI, nsIChannel* aChannel, bool aIsForeign,
bool aIsTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, bool aIsSafeTopLevelNav, bool aIsSameSiteForeign,
bool aHttpBound, const OriginAttributes& aOriginAttrs,
nsACString& aCookieString) {
bool aIsTrackingResource, bool aIsSocialTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign, bool aHttpBound,
const OriginAttributes& aOriginAttrs, nsACString& aCookieString) {
AutoTArray<nsCookie*, 8> foundCookieList;
GetCookiesForURI(aHostURI, aChannel, aIsForeign, aIsTrackingResource,
aFirstPartyStorageAccessGranted, aRejectedReason,
aIsSafeTopLevelNav, aIsSameSiteForeign, aHttpBound,
aOriginAttrs, foundCookieList);
aIsSocialTrackingResource, aFirstPartyStorageAccessGranted,
aRejectedReason, aIsSafeTopLevelNav, aIsSameSiteForeign,
aHttpBound, aOriginAttrs, foundCookieList);
nsCookie* cookie;
for (uint32_t i = 0; i < foundCookieList.Length(); ++i) {
@ -3965,9 +3971,10 @@ static inline bool IsSubdomainOf(const nsCString& a, const nsCString& b) {
CookieStatus nsCookieService::CheckPrefs(
nsICookieSettings* aCookieSettings, nsIURI* aHostURI, bool aIsForeign,
bool aIsTrackingResource, bool aFirstPartyStorageAccessGranted,
const nsACString& aCookieHeader, const int aNumOfCookies,
const OriginAttributes& aOriginAttrs, uint32_t* aRejectedReason) {
bool aIsTrackingResource, bool aIsSocialTrackingResource,
bool aFirstPartyStorageAccessGranted, const nsACString& aCookieHeader,
const int aNumOfCookies, const OriginAttributes& aOriginAttrs,
uint32_t* aRejectedReason) {
nsresult rv;
MOZ_ASSERT(aRejectedReason);
@ -4031,7 +4038,12 @@ CookieStatus nsCookieService::CheckPrefs(
COOKIE_LOGFAILURE(aCookieHeader.IsVoid() ? GET_COOKIE : SET_COOKIE,
aHostURI, aCookieHeader,
"cookies are disabled in trackers");
if (aIsSocialTrackingResource) {
*aRejectedReason =
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
} else {
*aRejectedReason = nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER;
}
return STATUS_REJECTED;
}

27
netwerk/cookie/nsCookieService.h
View File

@ -214,9 +214,10 @@ class nsCookieService final : public nsICookieService,
mozIThirdPartyUtil* aThirdPartyUtil);
static CookieStatus CheckPrefs(
nsICookieSettings* aCookieSettings, nsIURI* aHostURI, bool aIsForeign,
bool aIsTrackingResource, bool aIsFirstPartyStorageAccessGranted,
const nsACString& aCookieHeader, const int aNumOfCookies,
const OriginAttributes& aOriginAttrs, uint32_t* aRejectedReason);
bool aIsTrackingResource, bool aIsSocialTrackingResource,
bool aIsFirstPartyStorageAccessGranted, const nsACString& aCookieHeader,
const int aNumOfCookies, const OriginAttributes& aOriginAttrs,
uint32_t* aRejectedReason);
static int64_t ParseServerTime(const nsACString& aServerTime);
static already_AddRefed<nsICookieSettings> GetCookieSettings(
@ -224,6 +225,7 @@ class nsCookieService final : public nsICookieService,
void GetCookiesForURI(nsIURI* aHostURI, nsIChannel* aChannel, bool aIsForeign,
bool aIsTrackingResource,
bool aIsSocialTrackingResource,
bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, bool aIsSafeTopLevelNav,
bool aIsSameSiteForeign, bool aHttpBound,
@ -256,22 +258,21 @@ class nsCookieService final : public nsICookieService,
nsresult NormalizeHost(nsCString& aHost);
nsresult GetCookieStringCommon(nsIURI* aHostURI, nsIChannel* aChannel,
bool aHttpBound, nsACString& aCookie);
void GetCookieStringInternal(nsIURI* aHostURI, nsIChannel* aChannel,
bool aIsForeign, bool aIsTrackingResource,
bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign,
bool aHttpBound,
const OriginAttributes& aOriginAttrs,
nsACString& aCookie);
void GetCookieStringInternal(
nsIURI* aHostURI, nsIChannel* aChannel, bool aIsForeign,
bool aIsTrackingResource, bool aIsSocialTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
bool aIsSafeTopLevelNav, bool aIsSameSiteForeign, bool aHttpBound,
const OriginAttributes& aOriginAttrs, nsACString& aCookie);
nsresult SetCookieStringCommon(nsIURI* aHostURI,
const nsACString& aCookieHeader,
const nsACString& aServerTime,
nsIChannel* aChannel, bool aFromHttp);
void SetCookieStringInternal(
nsIURI* aHostURI, bool aIsForeign, bool aIsTrackingResource,
bool aFirstPartyStorageAccessGranted, uint32_t aRejectedReason,
nsCString& aCookieHeader, const nsACString& aServerTime, bool aFromHttp,
bool aIsSocialTrackingResource, bool aFirstPartyStorageAccessGranted,
uint32_t aRejectedReason, nsCString& aCookieHeader,
const nsACString& aServerTime, bool aFromHttp,
const OriginAttributes& aOriginAttrs, nsIChannel* aChannel);
bool SetCookieInternal(nsIURI* aHostURI, const nsCookieKey& aKey,
bool aRequireHostMatch, CookieStatus aStatus,

13
netwerk/ipc/DocumentChannelChild.cpp
View File

@ -616,6 +616,19 @@ DocumentChannelChild::IsThirdPartyTrackingResource(bool* aIsTrackingResource) {
return NS_OK;
}
NS_IMETHODIMP
DocumentChannelChild::IsSocialTrackingResource(
bool* aIsSocialTrackingResource) {
MOZ_ASSERT(!mFirstPartyClassificationFlags ||
!mThirdPartyClassificationFlags);
*aIsSocialTrackingResource =
UrlClassifierCommon::IsSocialTrackingClassificationFlag(
mThirdPartyClassificationFlags) ||
UrlClassifierCommon::IsSocialTrackingClassificationFlag(
mFirstPartyClassificationFlags);
return NS_OK;
}
NS_IMETHODIMP
DocumentChannelChild::GetClassificationFlags(uint32_t* aClassificationFlags) {
MOZ_ASSERT(aClassificationFlags);

12
netwerk/protocol/http/HttpBaseChannel.cpp
View File

@ -1496,6 +1496,18 @@ HttpBaseChannel::IsThirdPartyTrackingResource(bool* aIsTrackingResource) {
return NS_OK;
}
NS_IMETHODIMP
HttpBaseChannel::IsSocialTrackingResource(bool* aIsSocialTrackingResource) {
MOZ_ASSERT(!mFirstPartyClassificationFlags ||
!mThirdPartyClassificationFlags);
*aIsSocialTrackingResource =
UrlClassifierCommon::IsSocialTrackingClassificationFlag(
mThirdPartyClassificationFlags) ||
UrlClassifierCommon::IsSocialTrackingClassificationFlag(
mFirstPartyClassificationFlags);
return NS_OK;
}
NS_IMETHODIMP
HttpBaseChannel::GetClassificationFlags(uint32_t* aFlags) {
if (mThirdPartyClassificationFlags) {

13
netwerk/url-classifier/UrlClassifierCommon.cpp
View File

@ -554,8 +554,7 @@ bool UrlClassifierCommon::IsTrackingClassificationFlag(uint32_t aFlag) {
}
if (StaticPrefs::privacy_socialtracking_block_cookies_enabled() &&
(aFlag & nsIClassifiedChannel::ClassificationFlags::
CLASSIFIED_ANY_SOCIAL_TRACKING)) {
IsSocialTrackingClassificationFlag(aFlag)) {
return true;
}
@ -564,6 +563,16 @@ bool UrlClassifierCommon::IsTrackingClassificationFlag(uint32_t aFlag) {
nsIClassifiedChannel::ClassificationFlags::CLASSIFIED_ANY_BASIC_TRACKING);
}
// static
bool UrlClassifierCommon::IsSocialTrackingClassificationFlag(uint32_t aFlag) {
if (aFlag & nsIClassifiedChannel::ClassificationFlags::
CLASSIFIED_ANY_SOCIAL_TRACKING) {
return true;
}
return false;
}
// static
bool UrlClassifierCommon::IsCryptominingClassificationFlag(uint32_t aFlag) {
if (aFlag &

2
netwerk/url-classifier/UrlClassifierCommon.h
View File

@ -60,6 +60,8 @@ class UrlClassifierCommon final {
static bool IsTrackingClassificationFlag(uint32_t aFlag);
static bool IsSocialTrackingClassificationFlag(uint32_t aFlag);
static bool IsCryptominingClassificationFlag(uint32_t aFlag);
// Join the table names in 1 single string.

4
security/manager/ssl/nsSecureBrowserUIImpl.cpp
View File

@ -225,6 +225,10 @@ void nsSecureBrowserUIImpl::CheckForContentBlockingEvents() {
mEvent |= STATE_COOKIES_BLOCKED_TRACKER;
}
if (doc->GetHasSocialTrackingCookiesBlocked()) {
mEvent |= STATE_COOKIES_BLOCKED_SOCIALTRACKER;
}
if (doc->GetHasForeignCookiesBlocked()) {
mEvent |= STATE_COOKIES_BLOCKED_FOREIGN;
}

31
toolkit/components/antitracking/AntiTrackingCommon.cpp
View File

@ -393,6 +393,8 @@ void ReportBlockingToConsole(nsPIDOMWindowOuter* aWindow, nsIURI* aURI,
nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_PARTITIONED_FOREIGN ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
@ -1448,6 +1450,18 @@ bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
LOG(("Our window isn't a third-party tracking window"));
return true;
}
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(document->GetChannel());
if (classifiedChannel) {
uint32_t classificationFlags =
classifiedChannel->GetThirdPartyClassificationFlags();
if (classificationFlags & nsIClassifiedChannel::ClassificationFlags::
CLASSIFIED_SOCIALTRACKING) {
blockedReason =
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
}
}
} else {
MOZ_ASSERT(behavior ==
nsICookieService::BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN);
@ -1689,11 +1703,20 @@ bool AntiTrackingCommon::IsFirstPartyStorageAccessGrantedFor(
nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
do_QueryInterface(aChannel);
if (behavior == nsICookieService::BEHAVIOR_REJECT_TRACKER) {
if (classifiedChannel &&
!classifiedChannel->IsThirdPartyTrackingResource()) {
if (classifiedChannel) {
if (!classifiedChannel->IsThirdPartyTrackingResource()) {
LOG(("Our channel isn't a third-party tracking channel"));
return true;
}
uint32_t classificationFlags =
classifiedChannel->GetThirdPartyClassificationFlags();
if (classificationFlags & nsIClassifiedChannel::ClassificationFlags::
CLASSIFIED_SOCIALTRACKING) {
blockedReason =
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER;
}
}
} else {
MOZ_ASSERT(behavior ==
nsICookieService::BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN);
@ -2029,6 +2052,8 @@ void AntiTrackingCommon::NotifyBlockingDecision(nsIChannel* aChannel,
nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_PARTITIONED_FOREIGN ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||
@ -2092,6 +2117,8 @@ void AntiTrackingCommon::NotifyBlockingDecision(nsPIDOMWindowInner* aWindow,
nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_PARTITIONED_FOREIGN ||
aRejectedReason == nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL ||

2
toolkit/components/antitracking/AntiTrackingCommon.h
View File

@ -42,6 +42,7 @@ class AntiTrackingCommon final {
// storage permission is not granted:
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN
static bool IsFirstPartyStorageAccessGrantedFor(
@ -162,6 +163,7 @@ class AntiTrackingCommon final {
// aRejectedReason must be one of these values:
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_BY_PERMISSION
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_ALL
// * nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN
static void NotifyBlockingDecision(nsIChannel* aChannel,

10
toolkit/components/antitracking/StorageAccess.cpp
View File

@ -145,7 +145,9 @@ static StorageAccess InternalStorageAllowedCheck(
// We want to have a partitioned storage only for trackers.
if (aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER) {
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER) {
return StorageAccess::ePartitionTrackersOrDeny;
}
@ -320,6 +322,8 @@ bool ShouldPartitionStorage(StorageAccess aAccess) {
bool ShouldPartitionStorage(uint32_t aRejectedReason) {
return aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_PARTITIONED_FOREIGN;
}
@ -341,7 +345,9 @@ bool StoragePartitioningEnabled(StorageAccess aAccess,
bool StoragePartitioningEnabled(uint32_t aRejectedReason,
nsICookieSettings* aCookieSettings) {
if (aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER) {
nsIWebProgressListener::STATE_COOKIES_BLOCKED_TRACKER ||
aRejectedReason ==
nsIWebProgressListener::STATE_COOKIES_BLOCKED_SOCIALTRACKER) {
return aCookieSettings->GetCookieBehavior() ==
nsICookieService::BEHAVIOR_REJECT_TRACKER &&
StaticPrefs::privacy_storagePrincipal_enabledForTrackers();

20
toolkit/components/antitracking/TrackingDBService.jsm
View File

@ -178,27 +178,20 @@ TrackingDBService.prototype = {
identifyType(events) {
let result = null;
let isTracker = false;
let isSocialTracker = false;
for (let [state, blocked] of events) {
if (state & Ci.nsIWebProgressListener.STATE_LOADED_TRACKING_CONTENT) {
isTracker = true;
}
if (
state & Ci.nsIWebProgressListener.STATE_LOADED_SOCIALTRACKING_CONTENT
) {
isSocialTracker = true;
}
if (blocked) {
if (
state & Ci.nsIWebProgressListener.STATE_BLOCKED_FINGERPRINTING_CONTENT
) {
result = Ci.nsITrackingDBService.FINGERPRINTERS_ID;
} else if (
// If STP is enabled and either a social tracker is blocked,
// or a cookie was blocked with a social tracking event
// If STP is enabled and either a social tracker or cookie is blocked.
social_enabled &&
((isSocialTracker &&
state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER) ||
(state &
Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_SOCIALTRACKER ||
state &
Ci.nsIWebProgressListener.STATE_BLOCKED_SOCIALTRACKING_CONTENT)
) {
@ -210,9 +203,10 @@ TrackingDBService.prototype = {
) {
result = Ci.nsITrackingDBService.TRACKERS_ID;
} else if (
// If a tracking cookie was blocked attribute it to tracking cookies. Possible social tracking content,
// but STP is not enabled.
state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER
// If a tracking cookie was blocked attribute it to tracking cookies.
// This includes social tracking cookies since STP is not enabled.
state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_TRACKER ||
state & Ci.nsIWebProgressListener.STATE_COOKIES_BLOCKED_SOCIALTRACKER
) {
result = Ci.nsITrackingDBService.TRACKING_COOKIES_ID;
} else if (

5
uriloader/base/nsIWebProgressListener.idl
View File

@ -310,6 +310,10 @@ interface nsIWebProgressListener : nsISupports
* Rejected because the resource is a tracker and cookie policy doesn't
* allow its loading.
*
* STATE_COOKIES_BLOCKED_SOCIALTRACKER
* Rejected because the resource is a tracker from a social origin and
* cookie policy doesn't allow its loading.
*
* STATE_COOKIES_PARTITIONED_FOREIGN
* Rejected because the resource is a third-party and cookie policy forces
* third-party resources to be partitioned.
@ -338,6 +342,7 @@ interface nsIWebProgressListener : nsISupports
const unsigned long STATE_COOKIES_LOADED_SOCIALTRACKER = 0x00080000;
const unsigned long STATE_COOKIES_BLOCKED_BY_PERMISSION = 0x10000000;
const unsigned long STATE_COOKIES_BLOCKED_TRACKER = 0x20000000;
const unsigned long STATE_COOKIES_BLOCKED_SOCIALTRACKER = 0x01000000;
const unsigned long STATE_COOKIES_BLOCKED_ALL = 0x40000000;
const unsigned long STATE_COOKIES_PARTITIONED_FOREIGN = 0x80000000;
const unsigned long STATE_COOKIES_BLOCKED_FOREIGN = 0x00000080;