firefox-main/toolkit/components/resistfingerprinting/nsRFPService.h (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 https://mozilla.org/MPL/2.0/. */
#ifndef _nsRFPService_h_
#define _nsRFPService_h_
#include <cstdint>
#include <bitset>
#include "ErrorList.h"
#include "PLDHashTable.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/TypedEnumBits.h"
#include "mozilla/dom/MediaDeviceInfoBinding.h"
#include "mozilla/dom/ScreenOrientationBinding.h"
#include "js/RealmOptions.h"
#include "nsHashtablesFwd.h"
#include "nsICookieJarSettings.h"
#include "nsIFingerprintingWebCompatService.h"
#include "nsIObserver.h"
#include "nsISupports.h"
#include "nsIRFPService.h"
#include "nsStringFwd.h"
#include <queue>
// Defines regarding spoofed values of Navigator object. These spoofed values
// are returned when 'privacy.resistFingerprinting' is true.
// We decided to give different spoofed values according to the platform. The
// reason is that it is easy to detect the real platform. So there is no benefit
// for hiding the platform: it only brings breakages, like keyboard shortcuts
// won't work in macOS if we spoof it as a Windows platform.
// We use this value for Desktop mode in Android.
// That's why it is defined here, outside of
// the platform-specific definitions.
#define SPOOFED_UA_OS_OTHER "X11; Linux x86_64"
#ifdef XP_WIN
# define SPOOFED_UA_OS "Windows NT 10.0; Win64; x64"
# define SPOOFED_APPVERSION "5.0 (Windows)"
# define SPOOFED_OSCPU "Windows NT 10.0; Win64; x64"
# define SPOOFED_MAX_TOUCH_POINTS 10
#elif defined(XP_MACOSX)
# define SPOOFED_UA_OS "Macintosh; Intel Mac OS X 10.15"
# define SPOOFED_APPVERSION "5.0 (Macintosh)"
# define SPOOFED_OSCPU "Intel Mac OS X 10.15"
# define SPOOFED_MAX_TOUCH_POINTS 0
#elif defined(MOZ_WIDGET_ANDROID)
# define SPOOFED_UA_OS "Android 10; Mobile"
# define SPOOFED_APPVERSION "5.0 (Android 10)"
# define SPOOFED_OSCPU "Linux armv81"
# define SPOOFED_MAX_TOUCH_POINTS 5
#else
// For Linux and other platforms, like BSDs, SunOS and etc, we will use Linux
// platform.
# define SPOOFED_UA_OS SPOOFED_UA_OS_OTHER
# define SPOOFED_APPVERSION "5.0 (X11)"
# define SPOOFED_OSCPU "Linux x86_64"
# define SPOOFED_MAX_TOUCH_POINTS 5
#endif
#define LEGACY_BUILD_ID "20181001000000"
#define LEGACY_UA_GECKO_TRAIL "20100101"
#define SPOOFED_POINTER_INTERFACE MouseEvent_Binding::MOZ_SOURCE_MOUSE
struct JSContext;
class nsIChannel;
class nsICanvasRenderingContextInternal;
namespace mozilla {
class WidgetKeyboardEvent;
class OriginAttributes;
class OriginAttributesPattern;
namespace dom {
class Document;
enum class CanvasContextType : uint8_t;
} // namespace dom
namespace gfx {
class DataSourceSurface;
} // namespace gfx
enum KeyboardLang { EN = 0x01 };
#define RFP_KEYBOARD_LANG_STRING_EN "en"
typedef uint8_t KeyboardLangs;
enum KeyboardRegion { US = 0x01 };
#define RFP_KEYBOARD_REGION_STRING_US "US"
typedef uint8_t KeyboardRegions;
// This struct has the information about how to spoof the keyboardEvent.code,
// keyboardEvent.keycode and modifier states.
struct SpoofingKeyboardCode {
CodeNameIndex mCode;
uint8_t mKeyCode;
Modifiers mModifierStates;
};
struct SpoofingKeyboardInfo {
nsString mKey;
KeyNameIndex mKeyIdx;
SpoofingKeyboardCode mSpoofingCode;
};
class KeyboardHashKey : public PLDHashEntryHdr {
public:
typedef const KeyboardHashKey& KeyType;
typedef const KeyboardHashKey* KeyTypePointer;
KeyboardHashKey(const KeyboardLangs aLang, const KeyboardRegions aRegion,
const KeyNameIndex aKeyIdx, const nsAString& aKey);
explicit KeyboardHashKey(KeyTypePointer aOther);
KeyboardHashKey(KeyboardHashKey&& aOther) noexcept;
~KeyboardHashKey();
bool KeyEquals(KeyTypePointer aOther) const;
static KeyTypePointer KeyToPointer(KeyType aKey);
static PLDHashNumber HashKey(KeyTypePointer aKey);
enum { ALLOW_MEMMOVE = true };
KeyboardLangs mLang;
KeyboardRegions mRegion;
KeyNameIndex mKeyIdx;
nsString mKey;
};
// ============================================================================
// Reduce Timer Precision (RTP) Caller Type
enum class RTPCallerType : uint8_t {
Normal = 0,
SystemPrincipal = (1 << 0),
ResistFingerprinting = (1 << 1),
CrossOriginIsolated = (1 << 2)
};
inline JS::RTPCallerTypeToken RTPCallerTypeToToken(RTPCallerType aType) {
return JS::RTPCallerTypeToken{uint8_t(aType)};
}
inline RTPCallerType RTPCallerTypeFromToken(JS::RTPCallerTypeToken aToken) {
MOZ_RELEASE_ASSERT(
aToken.value == uint8_t(RTPCallerType::Normal) ||
aToken.value == uint8_t(RTPCallerType::SystemPrincipal) ||
aToken.value == uint8_t(RTPCallerType::ResistFingerprinting) ||
aToken.value == uint8_t(RTPCallerType::CrossOriginIsolated));
return static_cast<RTPCallerType>(aToken.value);
}
enum TimerPrecisionType {
DangerouslyNone = 1,
UnconditionalAKAHighRes = 2,
Normal = 3,
RFP = 4,
};
// ============================================================================
enum class CanvasFeatureUsage : uint64_t {
None = 0,
KnownText_1 = 1llu << 0,
KnownText_2 = 1llu << 1,
KnownText_3 = 1llu << 2,
KnownText_4 = 1llu << 3,
KnownText_5 = 1llu << 4,
KnownText_6 = 1llu << 5,
KnownText_7 = 1llu << 6,
KnownText_8 = 1llu << 7,
KnownText_9 = 1llu << 8,
KnownText_10 = 1llu << 9,
KnownText_11 = 1llu << 10,
KnownText_12 = 1llu << 11,
KnownText_13 = 1llu << 12,
KnownText_14 = 1llu << 13,
KnownText_15 = 1llu << 14,
KnownText_16 = 1llu << 15,
KnownText_17 = 1llu << 16,
KnownText_18 = 1llu << 17,
KnownText_19 = 1llu << 18,
KnownText_20 = 1llu << 19,
KnownText_21 = 1llu << 20,
KnownText_22 = 1llu << 21,
KnownText_23 = 1llu << 22,
KnownText_24 = 1llu << 23,
KnownText_25 = 1llu << 24,
KnownText_26 = 1llu << 25,
KnownText_27 = 1llu << 26,
KnownText_28 = 1llu << 27,
KnownText_29 = 1llu << 28,
KnownText_30 = 1llu << 29,
KnownText_31 = 1llu << 30,
KnownText_32 = 1llu << 31,
SetFont = 1llu << 32,
FillRect = 1llu << 33,
LineTo = 1llu << 34,
Stroke = 1llu << 35,
};
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(CanvasFeatureUsage);
// We try to classify observed canvas fingerprinting scripts into different
// classes, but we don't usually know the source/vendor of those scripts. The
// classification is based on a behavioral analysis covering things like the
// functions called and size of the canvas. The alias given is a guess and
// should not be considered definitive. The entity identified may not be doing
// this behavior at all, they may be doing a diferent or additional behaviors.
enum CanvasFingerprinterAlias {
eNoneIdentified = 0,
eFingerprintJS = 1,
eAkamai = 2,
eOzoki = 3,
ePerimeterX = 4,
eSignifyd = 5,
eClaydar = 6,
eForter = 7,
// Variants are unknown but distinct types of fingerprinters
eVariant1 = 8,
eVariant2 = 9,
eVariant3 = 10,
eVariant4 = 11,
eVariant5 = 12,
eVariant6 = 13,
eVariant7 = 14,
eVariant8 = 15,
eClientGear = 16,
eImperva = 17,
eLastAlias = eImperva
};
enum CanvasExtractionAPI : uint8_t {
ToDataURL = 0,
ToBlob = 1,
GetImageData = 2,
ReadPixels = 3
};
enum CanvasUsageSource : uint64_t {
Unknown = 0,
Impossible =
1llu << 0, // This represents API calls that I don't believe are possible
MainThread_Canvas_ImageBitmap_toDataURL = 1llu << 1,
MainThread_Canvas_ImageBitmap_toBlob = 1llu << 2,
MainThread_Canvas_ImageBitmap_getImageData = 1llu << 3,
MainThread_Canvas_Canvas2D_toDataURL = 1llu << 4,
MainThread_Canvas_Canvas2D_toBlob = 1llu << 5,
MainThread_Canvas_Canvas2D_getImageData = 1llu << 6,
MainThread_Canvas_WebGL_toDataURL = 1llu << 7,
MainThread_Canvas_WebGL_toBlob = 1llu << 8,
MainThread_Canvas_WebGL_getImageData = 1llu << 9,
MainThread_Canvas_WebGL_readPixels = 1llu << 10,
MainThread_Canvas_WebGPU_toDataURL = 1llu << 11,
MainThread_Canvas_WebGPU_toBlob = 1llu << 12,
MainThread_Canvas_WebGPU_getImageData = 1llu << 13,
MainThread_OffscreenCanvas_ImageBitmap_toDataURL = 1llu << 14,
MainThread_OffscreenCanvas_ImageBitmap_toBlob = 1llu << 15,
MainThread_OffscreenCanvas_ImageBitmap_getImageData = 1llu << 16,
MainThread_OffscreenCanvas_Canvas2D_toDataURL = 1llu << 17,
MainThread_OffscreenCanvas_Canvas2D_toBlob = 1llu << 18,
MainThread_OffscreenCanvas_Canvas2D_getImageData = 1llu << 19,
MainThread_OffscreenCanvas_WebGL_toDataURL = 1llu << 20,
MainThread_OffscreenCanvas_WebGL_toBlob = 1llu << 21,
MainThread_OffscreenCanvas_WebGL_getImageData = 1llu << 22,
MainThread_OffscreenCanvas_WebGL_readPixels = 1llu << 23,
MainThread_OffscreenCanvas_WebGPU_toDataURL = 1llu << 24,
MainThread_OffscreenCanvas_WebGPU_toBlob = 1llu << 25,
MainThread_OffscreenCanvas_WebGPU_getImageData = 1llu << 26,
Worker_OffscreenCanvas_ImageBitmap_toBlob = 1llu << 27,
Worker_OffscreenCanvas_ImageBitmap_getImageData = 1llu << 28,
Worker_OffscreenCanvas_Canvas2D_toBlob = 1llu << 29,
Worker_OffscreenCanvas_Canvas2D_getImageData = 1llu << 30,
Worker_OffscreenCanvasCanvas2D_Canvas2D_toBlob = 1llu << 31,
Worker_OffscreenCanvasCanvas2D_Canvas2D_getImageData = 1llu << 32,
Worker_OffscreenCanvas_WebGL_toBlob = 1llu << 33,
Worker_OffscreenCanvas_WebGL_getImageData = 1llu << 34,
Worker_OffscreenCanvas_WebGL_readPixels = 1llu << 35,
Worker_OffscreenCanvas_WebGPU_toBlob = 1llu << 36,
Worker_OffscreenCanvas_WebGPU_getImageData = 1llu << 37,
// --- New entires added here to preserve original values (no reordering!)
MainThread_Canvas_OffscreenCanvas2D_getImageData = 1llu << 38,
MainThread_Canvas_OffscreenCanvas2D_toBlob = 1llu << 39,
// After you go past 40 - metrics.yaml will need to be updated
};
MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(CanvasUsageSource);
nsCString CanvasUsageSourceToString(CanvasUsageSource aSource);
class CanvasUsage {
public:
CSSIntSize mSize;
dom::CanvasContextType mType;
CanvasUsageSource mUsageSource;
CanvasFeatureUsage mFeatureUsage;
CanvasUsage(CSSIntSize aSize, dom::CanvasContextType aType,
CanvasUsageSource aUsageSource, CanvasFeatureUsage aFeatureUsage)
: mSize(aSize),
mType(aType),
mUsageSource(aUsageSource),
mFeatureUsage(aFeatureUsage) {}
static CanvasUsage CreateUsage(
bool aIsOffscreen, dom::CanvasContextType aContextType,
CanvasExtractionAPI aApi, CSSIntSize aSize,
const nsICanvasRenderingContextInternal* aContext);
static inline CanvasUsageSource GetCanvasUsageSource(
bool isOffscreen, dom::CanvasContextType contextType,
CanvasExtractionAPI api);
};
struct CanvasFingerprintingEvent {
// The identity or alias of the entity doing the fingerprinting.
CanvasFingerprinterAlias alias;
// A bitmask of all of the known canvas fingerprinting texts
// non-zero indicates some known fingerprinting text was used, making the
// event highly likely to be fingerprinting.
uint32_t knownTextBitmask;
// A bitmap of all the sources that were used to extract canvas data
uint64_t sourcesBitmask;
CanvasFingerprintingEvent()
: alias(CanvasFingerprinterAlias::eNoneIdentified),
knownTextBitmask(0),
sourcesBitmask(0) {}
CanvasFingerprintingEvent(CanvasFingerprinterAlias aAlias,
uint32_t aKnownTextBitmask,
uint64_t aSourcesBitmask)
: alias(aAlias),
knownTextBitmask(aKnownTextBitmask),
sourcesBitmask(aSourcesBitmask) {}
bool operator==(const CanvasFingerprintingEvent& other) const {
return alias == other.alias && knownTextBitmask == other.knownTextBitmask &&
sourcesBitmask == other.sourcesBitmask;
}
};
// ============================================================================
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define ITEM_VALUE(name, val) name = val,
// The definition for fingerprinting protections. Each enum represents one
// fingerprinting protection that targets one specific WebAPI our fingerprinting
// surface. The enums can be found in RFPTargets.inc.
enum class RFPTarget : uint64_t {
#include "RFPTargets.inc"
};
#undef ITEM_VALUE
using RFPTargetSet = EnumSet<RFPTarget, std::bitset<128>>;
template <>
struct MaxEnumValue<RFPTarget> {
static constexpr unsigned int value = 127;
};
// ============================================================================
class nsRFPService final : public nsIObserver, public nsIRFPService {
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
NS_DECL_NSIRFPSERVICE
static already_AddRefed<nsRFPService> GetOrCreate();
// _Rarely_ you will need to know if RFP is enabled, or if FPP is enabled.
// 98% of the time you should use nsContentUtils::ShouldResistFingerprinting
// as the difference will not matter to you.
static bool IsRFPPrefEnabled(bool aIsPrivateMode);
static bool IsRFPEnabledFor(
bool aIsPrivateMode, RFPTarget aTarget,
const Maybe<RFPTargetSet>& aOverriddenFingerprintingSettings);
static bool IsSystemPrincipalOrAboutFingerprintingProtection(JSContext*,
JSObject*);
// --------------------------------------------------------------------------
static double TimerResolution(RTPCallerType aRTPCallerType);
enum TimeScale { Seconds = 1, MilliSeconds = 1000, MicroSeconds = 1000000 };
// The following Reduce methods can be called off main thread.
static double ReduceTimePrecisionAsUSecs(double aTime, int64_t aContextMixin,
RTPCallerType aRTPCallerType);
static double ReduceTimePrecisionAsMSecs(double aTime, int64_t aContextMixin,
RTPCallerType aRTPCallerType);
static double ReduceTimePrecisionAsMSecsRFPOnly(double aTime,
int64_t aContextMixin,
RTPCallerType aRTPCallerType);
static double ReduceTimePrecisionAsSecs(double aTime, int64_t aContextMixin,
RTPCallerType aRTPCallerType);
static double ReduceTimePrecisionAsSecsRFPOnly(double aTime,
int64_t aContextMixin,
RTPCallerType aRTPCallerType);
// Public only for testing purposes
static double ReduceTimePrecisionImpl(double aTime, TimeScale aTimeScale,
double aResolutionUSec,
int64_t aContextMixin,
TimerPrecisionType aType);
static nsresult RandomMidpoint(long long aClampedTimeUSec,
long long aResolutionUSec,
int64_t aContextMixin, long long* aMidpointOut,
uint8_t* aSecretSeed = nullptr);
// --------------------------------------------------------------------------
// This method calculates the video resolution (i.e. height x width) based
// on the video quality (480p, 720p, etc).
static uint32_t CalculateTargetVideoResolution(uint32_t aVideoQuality);
// Methods for getting spoofed media statistics and the return value will
// depend on the video resolution.
static uint32_t GetSpoofedTotalFrames(double aTime);
static uint32_t GetSpoofedDroppedFrames(double aTime, uint32_t aWidth,
uint32_t aHeight);
static uint32_t GetSpoofedPresentedFrames(double aTime, uint32_t aWidth,
uint32_t aHeight);
// --------------------------------------------------------------------------
// This method generates the spoofed value of User Agent.
static void GetSpoofedUserAgent(nsACString& userAgent,
bool aAndroidDesktopMode = false);
// --------------------------------------------------------------------------
// This method generates the locale string (e.g. "en-US") that should be
// spoofed by the JavaScript engine.
static nsCString GetSpoofedJSLocale();
// --------------------------------------------------------------------------
// This method generates the time zone string (e.g. "Atlantic/Reykjavik") that
// should be spoofed by the JavaScript engine.
static nsCString GetSpoofedJSTimeZone();
// --------------------------------------------------------------------------
/**
* This method for getting spoofed modifier states for the given keyboard
* event.
*
* @param aDoc [in] the owner's document for getting content
* language.
* @param aKeyboardEvent [in] the keyboard event that needs to be spoofed.
* @param aModifier [in] the modifier that needs to be spoofed.
* @param aOut [out] the spoofed state for the given modifier.
* @return true if there is a spoofed state for the modifier.
*/
static bool GetSpoofedModifierStates(
const mozilla::dom::Document* aDoc,
const WidgetKeyboardEvent* aKeyboardEvent, const Modifiers aModifier,
bool& aOut);
/**
* This method for getting spoofed code for the given keyboard event.
*
* @param aDoc [in] the owner's document for getting content
* language.
* @param aKeyboardEvent [in] the keyboard event that needs to be spoofed.
* @param aOut [out] the spoofed code.
* @return true if there is a spoofed code in the fake keyboard
* layout.
*/
static bool GetSpoofedCode(const dom::Document* aDoc,
const WidgetKeyboardEvent* aKeyboardEvent,
nsAString& aOut);
/**
* This method for getting spoofed keyCode for the given keyboard event.
*
* @param aDoc [in] the owner's document for getting content
* language.
* @param aKeyboardEvent [in] the keyboard event that needs to be spoofed.
* @param aOut [out] the spoofed keyCode.
* @return true if there is a spoofed keyCode in the fake
* keyboard layout.
*/
static bool GetSpoofedKeyCode(const mozilla::dom::Document* aDoc,
const WidgetKeyboardEvent* aKeyboardEvent,
uint32_t& aOut);
// --------------------------------------------------------------------------
// The method to generate the key for randomization. It can return nothing if
// the session key is not available due to the randomization is disabled.
static Maybe<nsTArray<uint8_t>> GenerateKey(nsIChannel* aChannel);
static Maybe<nsTArray<uint8_t>> GenerateKeyForServiceWorker(
nsIURI* aFirstPartyURI, nsIPrincipal* aPrincipal,
bool aForeignByAncestorContext);
static void PotentiallyDumpImage(nsIPrincipal* aPrincipal,
gfx::DataSourceSurface* aSurface);
static void PotentiallyDumpImage(nsIPrincipal* aPrincipal, uint8_t* aData,
uint32_t aWidth, uint32_t aHeight,
uint32_t aSize);
// This function is plumbed to RandomizeElements function.
static nsresult RandomizePixels(nsICookieJarSettings* aCookieJarSettings,
nsIPrincipal* aPrincipal, uint8_t* aData,
uint32_t aWidth, uint32_t aHeight,
uint32_t aSize,
mozilla::gfx::SurfaceFormat aSurfaceFormat);
// This function is used to randomize the elements in the given data
// according to the given parameters. For example, for an RGBA pixel, by group
// in this context, we refer to a single pixel and by element, we refer to
// channels. So, if we have an RGBA pixel, we have 4 elements per group, i.e.
// 4 channels per pixel. We use aElementsPerGroup to randomize at most one of
// elements per group, i.e. one channel per pixel.
static nsresult RandomizeElements(
nsICookieJarSettings* aCookieJarSettings, nsIPrincipal* aPrincipal,
uint8_t* aData, uint32_t aSizeInBytes, uint8_t aElementsPerGroup,
uint8_t aBytesPerElement, uint8_t aElementOffset, bool aSkipLastElement);
// --------------------------------------------------------------------------
// The method for getting the granular fingerprinting protection override of
// the given channel. Due to WebCompat reason, there can be a granular
// overrides to replace default enabled RFPTargets for the context of the
// channel. The method will return Nothing() to indicate using the default
// RFPTargets
static Maybe<RFPTargetSet> GetOverriddenFingerprintingSettingsForChannel(
nsIChannel* aChannel);
// The method for getting the granular fingerprinting protection override of
// the given first-party and third-party URIs. It will return the granular
// overrides if there is one defined for the context of the first-party URI
// and third-party URI. Otherwise, it will return Nothing() to indicate using
// the default RFPTargets.
static Maybe<RFPTargetSet> GetOverriddenFingerprintingSettingsForURI(
nsIURI* aFirstPartyURI, nsIURI* aThirdPartyURI, bool aIsPrivate);
// --------------------------------------------------------------------------
static void MaybeReportCanvasFingerprinter(nsTArray<CanvasUsage>& aUses,
nsIChannel* aChannel, nsIURI* aURI,
const nsACString& aOriginNoSuffix);
static void MaybeReportFontFingerprinter(nsIChannel* aChannel, nsIURI* aURI,
const nsACString& aOriginNoSuffix);
// --------------------------------------------------------------------------
// Generates a fake media device name with given kind and index.
// Example: Internal Microphone
static void GetMediaDeviceName(nsString& aName,
mozilla::dom::MediaDeviceKind aKind);
// Generates a fake media device group name with given kind and index.
// Example: Audio Group
static void GetMediaDeviceGroup(nsString& aGroup,
mozilla::dom::MediaDeviceKind aKind);
// Converts the viewport size to the angle.
static uint16_t ViewportSizeToAngle(int32_t aWidth, int32_t aHeight);
// Converts the viewport size to the orientation type.
static dom::OrientationType ViewportSizeToOrientationType(int32_t aWidth,
int32_t aHeight);
// Returns the default orientation type for the given platform.
static dom::OrientationType GetDefaultOrientationType();
// Returns the default pixel density for RFP.
static float GetDefaultPixelDensity();
// Returns the device pixel ratio at the given zoom level.
static double GetDevicePixelRatioAtZoom(float aZoom);
// Returns the value of privacy.resistFingerprinting.exemptedDomains pref
static void GetExemptedDomainsLowercase(nsCString& aExemptedDomains);
static CSSIntRect GetSpoofedScreenAvailSize(const nsRect& aRect, float aScale,
bool aIsFullscreen);
static uint64_t GetSpoofedStorageLimit();
static bool ExposeWebCodecsAPI(JSContext* aCx, JSObject* aObj);
static bool ExposeWebCodecsAPIImageDecoder(JSContext* aCx, JSObject* aObj);
static bool IsWebCodecsRFPTargetEnabled(JSContext* aCx);
static uint32_t CollapseMaxTouchPoints(uint32_t aMaxTouchPoints);
static void CalculateFontLocaleAllowlist();
static bool FontIsAllowedByLocale(const nsACString& aName);
static Maybe<RFPTarget> TextToRFPTarget(const nsAString& aText);
static void GetFingerprintingRandomizationKeyAsString(
nsICookieJarSettings* aCookieJarSettings,
nsACString& aRandomizationKeyStr);
static nsresult GenerateRandomizationKeyFromHash(
const nsACString& aRandomizationKeyStr, uint32_t aContentHash,
nsACString& aHex);
private:
nsresult Init();
nsRFPService() = default;
~nsRFPService() = default;
void UpdateFPPOverrideList();
void StartShutdown();
void PrefChanged(const char* aPref);
static void PrefChanged(const char* aPref, void* aSelf);
// --------------------------------------------------------------------------
static void MaybeCreateSpoofingKeyCodes(const KeyboardLangs aLang,
const KeyboardRegions aRegion);
static void MaybeCreateSpoofingKeyCodesForEnUS();
static void GetKeyboardLangAndRegion(const nsAString& aLanguage,
KeyboardLangs& aLocale,
KeyboardRegions& aRegion);
static bool GetSpoofedKeyCodeInfo(const mozilla::dom::Document* aDoc,
const WidgetKeyboardEvent* aKeyboardEvent,
SpoofingKeyboardCode& aOut);
static nsTHashMap<KeyboardHashKey, const SpoofingKeyboardCode*>*
sSpoofingKeyboardCodes;
// --------------------------------------------------------------------------
// Used by the JS Engine
static double ReduceTimePrecisionAsUSecsWrapper(
double aTime, JS::RTPCallerTypeToken aCallerType, JSContext* aCx);
static TimerPrecisionType GetTimerPrecisionType(RTPCallerType aRTPCallerType);
static TimerPrecisionType GetTimerPrecisionTypeRFPOnly(
RTPCallerType aRTPCallerType);
static void TypeToText(TimerPrecisionType aType, nsACString& aText);
// --------------------------------------------------------------------------
// A helper function to generate canvas key from the given image data and
// randomization key.
static nsresult GenerateCanvasKeyFromImageData(
nsICookieJarSettings* aCookieJarSettings, uint8_t* aImageData,
uint32_t aSize, nsTArray<uint8_t>& aCanvasKey);
// Generate the session key if it hasn't been generated.
nsresult GetBrowsingSessionKey(const OriginAttributes& aOriginAttributes,
nsID& aBrowsingSessionKey);
void ClearBrowsingSessionKey(const OriginAttributesPattern& aPattern);
void ClearBrowsingSessionKey(const OriginAttributes& aOriginAttributes);
// The keys that represent the browsing session. The lifetime of the key ties
// to the browsing session. For normal windows, the key is generated when
// loading the first http channel after the browser startup and persists until
// the browser shuts down. For private windows, the key is generated when
// opening a http channel on a private window and reset after all private
// windows close, i.e. private browsing session ends.
//
// The key will be used to generate the randomization noise used to fiddle the
// browser fingerprints. Note that this key lives and can only be accessed in
// the parent process.
nsTHashMap<nsCStringHashKey, nsID> mBrowsingSessionKeys;
nsCOMPtr<nsIFingerprintingWebCompatService> mWebCompatService;
nsTHashMap<nsCStringHashKey, RFPTargetSet> mFingerprintingOverrides;
// A helper function to create the domain key for the fingerprinting
// overrides. The key can be in the following five formats.
// 1. {first-party domain}: The override only apply to the first-party domain.
// 2. {first-party domain, *}: The overrides apply to every contexts under the
// top-level domain, including itself.
// 3. {*, third-party domain}: The overrides apply to the third-party domain
// under any top-level domain.
// 4. {first-party domain, third-party domain}: the overrides apply to the
// specific third-party domain under the given first-party domain.
// 5. {*}: A global overrides that will apply to every context.
static nsresult CreateOverrideDomainKey(nsIFingerprintingOverride* aOverride,
nsACString& aDomainKey);
// A helper function to create the RFPTarget bitfield based on the given
// overrides text and the based overrides bitfield. The function will parse
// the text and update the based overrides bitfield accordingly. Then, it will
// return the updated bitfield.
static RFPTargetSet CreateOverridesFromText(
const nsString& aOverridesText,
RFPTargetSet aBaseOverrides = RFPTargetSet());
enum FingerprintingProtectionType : uint8_t {
RFP,
FPP,
Baseline,
None,
};
static FingerprintingProtectionType GetFingerprintingProtectionType(
bool aIsPrivateMode);
static Maybe<bool> HandleExceptionalRFPTargets(
RFPTarget aTarget, bool aIsPrivateMode,
FingerprintingProtectionType aMode);
static bool IsTargetActiveForMode(RFPTarget aTarget,
FingerprintingProtectionType aMode);
static nsCString* sExemptedDomainsLowercase;
};
} // namespace mozilla
#endif /* _nsRFPService_h_ */