gecko-dev/netwerk/url-classifier/ChannelClassifierService.cpp

262 строки
7.3 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */
#include "ChannelClassifierService.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/dom/BrowserParent.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/CanonicalBrowsingContext.h"
#include "mozilla/dom/WindowGlobalParent.h"
#include "mozilla/net/UrlClassifierCommon.h"
#include "UrlClassifierFeatureCryptominingProtection.h"
#include "UrlClassifierFeatureFingerprintingProtection.h"
#include "UrlClassifierFeatureSocialTrackingProtection.h"
#include "UrlClassifierFeatureTrackingProtection.h"
namespace mozilla {
namespace net {
static StaticRefPtr<ChannelClassifierService> gChannelClassifierService;
NS_IMPL_ISUPPORTS(UrlClassifierBlockedChannel, nsIUrlClassifierBlockedChannel)
UrlClassifierBlockedChannel::UrlClassifierBlockedChannel(nsIChannel* aChannel)
: mChannel(aChannel),
mDecision(ChannelBlockDecision::Blocked),
mReason(TRACKING_PROTECTION) {
MOZ_ASSERT(aChannel);
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetReason(uint8_t* aReason) {
NS_ENSURE_ARG_POINTER(aReason);
*aReason = mReason;
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetUrl(nsAString& aUrl) {
nsCOMPtr<nsIURI> uri;
mChannel->GetURI(getter_AddRefs(uri));
if (uri) {
CopyUTF8toUTF16(uri->GetSpecOrDefault(), aUrl);
}
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetTabId(uint64_t* aTabId) {
NS_ENSURE_ARG_POINTER(aTabId);
*aTabId = 0;
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
RefPtr<dom::BrowsingContext> browsingContext;
nsresult rv =
loadInfo->GetTargetBrowsingContext(getter_AddRefs(browsingContext));
if (NS_WARN_IF(NS_FAILED(rv)) || !browsingContext) {
return NS_ERROR_FAILURE;
}
// Get top-level browsing context to ensure window global parent is ready
// to use, tabId is the same anyway.
dom::CanonicalBrowsingContext* top = browsingContext->Canonical()->Top();
dom::WindowGlobalParent* wgp = top->GetCurrentWindowGlobal();
if (!wgp) {
return NS_ERROR_FAILURE;
}
RefPtr<dom::BrowserParent> browserParent = wgp->GetBrowserParent();
if (!browserParent) {
return NS_ERROR_FAILURE;
}
*aTabId = browserParent->GetTabId();
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetChannelId(uint64_t* aChannelId) {
NS_ENSURE_ARG_POINTER(aChannelId);
nsCOMPtr<nsIIdentChannel> channel(do_QueryInterface(mChannel));
*aChannelId = channel ? channel->ChannelId() : 0;
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetTopLevelUrl(nsAString& aTopLevelUrl) {
nsCOMPtr<nsILoadInfo> loadInfo = mChannel->LoadInfo();
MOZ_ASSERT(loadInfo);
RefPtr<dom::BrowsingContext> browsingContext;
nsresult rv =
loadInfo->GetTargetBrowsingContext(getter_AddRefs(browsingContext));
if (NS_WARN_IF(NS_FAILED(rv)) || !browsingContext) {
return NS_ERROR_FAILURE;
}
// Get top-level browsing context to ensure window global parent is ready
// to use, tabId is the same anyway.
dom::CanonicalBrowsingContext* top = browsingContext->Canonical()->Top();
dom::WindowGlobalParent* wgp = top->GetCurrentWindowGlobal();
if (!wgp) {
return NS_ERROR_FAILURE;
}
RefPtr<nsIURI> uri = wgp->GetDocumentURI();
if (!uri) {
return NS_ERROR_FAILURE;
}
CopyUTF8toUTF16(uri->GetSpecOrDefault(), aTopLevelUrl);
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetTables(nsACString& aTables) {
aTables.Assign(mTables);
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::GetIsPrivateBrowsing(bool* aIsPrivateBrowsing) {
NS_ENSURE_ARG_POINTER(aIsPrivateBrowsing);
*aIsPrivateBrowsing = NS_UsePrivateBrowsing(mChannel);
return NS_OK;
}
NS_IMETHODIMP
UrlClassifierBlockedChannel::Unblock() {
UC_LOG(("ChannelClassifierService: unblock channel %p", mChannel.get()));
mDecision = ChannelBlockDecision::Unblocked;
return NS_OK;
}
void UrlClassifierBlockedChannel::SetReason(const nsACString& aFeatureName,
const nsACString& aTableName) {
mTables = aTableName;
nsCOMPtr<nsIUrlClassifierFeature> feature;
feature =
UrlClassifierFeatureTrackingProtection::GetIfNameMatches(aFeatureName);
if (feature) {
mReason = TRACKING_PROTECTION;
return;
}
feature = UrlClassifierFeatureSocialTrackingProtection::GetIfNameMatches(
aFeatureName);
if (feature) {
mReason = SOCIAL_TRACKING_PROTECTION;
return;
}
feature = UrlClassifierFeatureFingerprintingProtection::GetIfNameMatches(
aFeatureName);
if (feature) {
mReason = FINGERPRINTING_PROTECTION;
return;
}
feature = UrlClassifierFeatureCryptominingProtection::GetIfNameMatches(
aFeatureName);
if (feature) {
mReason = CRYPTOMINING_PROTECTION;
return;
}
}
NS_IMPL_ISUPPORTS(ChannelClassifierService, nsIChannelClassifierService)
// static
already_AddRefed<nsIChannelClassifierService>
ChannelClassifierService::GetSingleton() {
if (gChannelClassifierService) {
return do_AddRef(gChannelClassifierService);
}
gChannelClassifierService = new ChannelClassifierService();
ClearOnShutdown(&gChannelClassifierService);
return do_AddRef(gChannelClassifierService);
}
ChannelClassifierService::ChannelClassifierService() { mListeners.Clear(); }
NS_IMETHODIMP
ChannelClassifierService::AddListener(nsIObserver* aObserver) {
MOZ_ASSERT(aObserver);
MOZ_ASSERT(!mListeners.Contains(aObserver));
mListeners.AppendElement(aObserver);
return NS_OK;
}
NS_IMETHODIMP
ChannelClassifierService::RemoveListener(nsIObserver* aObserver) {
MOZ_ASSERT(aObserver);
MOZ_ASSERT(mListeners.Contains(aObserver));
mListeners.RemoveElement(aObserver);
return NS_OK;
}
/* static */
ChannelBlockDecision ChannelClassifierService::OnBeforeBlockChannel(
nsIChannel* aChannel, const nsACString& aFeatureName,
const nsACString& aTableName) {
MOZ_ASSERT(aChannel);
// Don't bother continuing if no one has ever registered listener
if (!gChannelClassifierService || !gChannelClassifierService->HasListener()) {
return ChannelBlockDecision::Blocked;
}
ChannelBlockDecision decision;
nsresult rv = gChannelClassifierService->OnBeforeBlockChannel(
aChannel, aFeatureName, aTableName, decision);
if (NS_WARN_IF(NS_FAILED(rv))) {
return ChannelBlockDecision::Blocked;
}
return decision;
}
nsresult ChannelClassifierService::OnBeforeBlockChannel(
nsIChannel* aChannel, const nsACString& aFeatureName,
const nsACString& aTableName, ChannelBlockDecision& aDecision) {
MOZ_ASSERT(aChannel);
aDecision = ChannelBlockDecision::Blocked;
RefPtr<UrlClassifierBlockedChannel> channel =
new UrlClassifierBlockedChannel(aChannel);
channel->SetReason(aFeatureName, aTableName);
for (const auto& listener : mListeners) {
listener->Observe(
NS_ISUPPORTS_CAST(nsIUrlClassifierBlockedChannel*, channel),
"urlclassifier-before-block-channel", nullptr);
if (channel->IsUnblocked()) {
aDecision = ChannelBlockDecision::Unblocked;
}
}
return NS_OK;
}
} // namespace net
} // namespace mozilla