mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
identity_seed() hashed the whole user agent, browser version included. A saved identity relaunched on a newer browser claims the new engine version and nothing else about the machine changes, yet its seed moved, so every Firefox release redrew its fonts, voices, GPU and media devices: a site holding the identity's cookies saw a different machine behind the same profile, the change #442/#765 guard against within one version. With the same launcher and the same fingerprint, a browser at 150.0.2 and one at 158.0 drew different fonts and a different GPU on Windows, macOS and Linux identities alike. The seed now hashes the UA with its rv: and Firefox/ versions taken out, in both launchers; the OS tokens stay, so identities still differ. Every pinned identity redraws once, on the release that carries this, and then stays put across later ones. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
267 lines
11 KiB
Python
267 lines
11 KiB
Python
"""Per-identity draws: unrelated launches must not share them, a pinned identity must.
|
|
|
|
identity_seed() used to hash only the UA, platform, screen size and core count.
|
|
Those take a handful of values per OS, so over 500 launches the seed took 12-30
|
|
distinct values, and every install drew its fonts, voices, GPU, media devices and
|
|
canvas/audio noise seeds from that same short list.
|
|
"""
|
|
|
|
from contextlib import contextmanager
|
|
from unittest import mock
|
|
|
|
import orjson
|
|
import pytest
|
|
|
|
from camoufox import cpu_affinity, utils
|
|
from camoufox import fingerprints as fp
|
|
|
|
|
|
@contextmanager
|
|
def host(browser_version="150.0.2"):
|
|
with mock.patch.object(utils, "get_screen_cons", lambda headless: None), (
|
|
mock.patch.object(utils, "has_display", lambda env: False)
|
|
), mock.patch.object(utils, "installed_verstr", lambda: browser_version), (
|
|
mock.patch.object(utils, "launch_path", lambda **kwargs: "/nonexistent/camoufox")
|
|
):
|
|
yield
|
|
|
|
|
|
def config_of(options):
|
|
env = options["env"]
|
|
chunks = sorted(
|
|
(int(k.rsplit("_", 1)[1]), v) for k, v in env.items() if k.startswith("CAMOU_CONFIG_")
|
|
)
|
|
return orjson.loads("".join(chunk for _, chunk in chunks))
|
|
|
|
|
|
def launch(browser_version="150.0.2", **kwargs):
|
|
kwargs.setdefault("os", "linux")
|
|
kwargs.setdefault("headless", True)
|
|
kwargs.setdefault("i_know_what_im_doing", True)
|
|
with host(browser_version):
|
|
return config_of(utils.launch_options(**kwargs))
|
|
|
|
|
|
DRAWN = ("fonts", "voices", "webGl:renderer")
|
|
|
|
|
|
def drawn(config):
|
|
return {k: orjson.dumps(config.get(k)) for k in DRAWN}
|
|
|
|
|
|
class TestUnpinnedLaunchesAreDistinct:
|
|
def test_same_presented_values_still_differ(self):
|
|
# The same UA/platform/screen/cores, i.e. what two users on the same
|
|
# common machine present, must not yield the same draws.
|
|
config = {"navigator.userAgent": "x", "navigator.platform": "Win32",
|
|
"screen.width": 1920, "screen.height": 1080, "navigator.hardwareConcurrency": 8}
|
|
seeds = {fp.identity_seed(config, fp.identity_salt()) for _ in range(200)}
|
|
assert len(seeds) == 200
|
|
|
|
|
|
class TestPinnedIdentityIsStable:
|
|
def test_fixed_fingerprint_reproduces_every_draw(self):
|
|
fingerprint = fp.generate_fingerprint(os="linux")
|
|
first = launch(fingerprint=fingerprint)
|
|
second = launch(fingerprint=fingerprint)
|
|
assert drawn(first) == drawn(second)
|
|
|
|
@pytest.mark.parametrize("os_name", ["windows", "macos", "linux"])
|
|
def test_a_browser_upgrade_keeps_every_draw(self, os_name):
|
|
# A saved identity relaunched on a newer browser: the UA claims the new
|
|
# engine version, and nothing else about the machine may change. The
|
|
# seed used to hash the whole UA, so every Firefox release redrew a
|
|
# pinned identity's fonts, voices, GPU and media devices.
|
|
fingerprint = fp.generate_fingerprint(os=os_name)
|
|
old = launch("150.0.2", os=os_name, fingerprint=fingerprint)
|
|
new = launch("158.0", os=os_name, fingerprint=fingerprint)
|
|
assert "Firefox/150.0" in old["navigator.userAgent"]
|
|
assert "Firefox/158.0" in new["navigator.userAgent"]
|
|
devices = lambda c: {k: v for k, v in c.items() if k.startswith("mediaDevices:")}
|
|
assert drawn(old) == drawn(new)
|
|
assert devices(old) and devices(old) == devices(new)
|
|
|
|
def test_fixed_preset_reproduces_every_draw(self):
|
|
preset = fp.get_random_preset(os="windows", ff_version="150")
|
|
assert preset, "no Windows presets bundled"
|
|
first = launch(os="windows", fingerprint_preset=preset)
|
|
second = launch(os="windows", fingerprint_preset=preset)
|
|
assert drawn(first) == drawn(second)
|
|
|
|
@pytest.mark.parametrize("os_name", ["windows", "macos", "linux"])
|
|
def test_every_bundled_preset_launches(self, os_name):
|
|
# The test above draws ONE preset at random, so a preset that cannot
|
|
# launch would show up as a flake rather than a failure. Every preset
|
|
# must launch with its own GPU and that GPU's recorded parameters.
|
|
presets = fp.load_presets("150")["presets"][os_name]
|
|
for i, preset in enumerate(presets):
|
|
config = launch(os=os_name, fingerprint_preset=preset)
|
|
assert config["webGl:renderer"] == preset["webgl"]["unmaskedRenderer"], (os_name, i)
|
|
assert config.get("webGl:parameters"), (os_name, i)
|
|
|
|
def test_salt_of_equal_objects_is_equal(self):
|
|
a = fp.generate_fingerprint(os="windows")
|
|
assert fp.identity_salt(a) == fp.identity_salt(a)
|
|
assert fp.identity_salt({"a": 1, "b": 2}) == fp.identity_salt({"b": 2, "a": 1})
|
|
|
|
|
|
def test_no_audio_seed_is_generated():
|
|
"""The browser renders audio as stock does: one value per CPU architecture
|
|
(ci/tribal-rules.yml: audio-is-not-noised). There is no seed to send."""
|
|
assert "audio:seed" not in launch()
|
|
for preset in (None, fp.get_random_preset(os="windows", ff_version="150")):
|
|
context = fp.generate_context_fingerprint(os="windows", preset=preset)
|
|
assert "audio:seed" not in context["config"]
|
|
assert "setAudioFingerprintSeed" not in context["init_script"]
|
|
|
|
|
|
def _removed_audio_warnings(record):
|
|
return [w for w in record if w.category is FutureWarning and "audio:seed" in str(w.message)]
|
|
|
|
|
|
def test_an_audio_seed_warns_once_and_is_dropped():
|
|
"""A caller's seed would do nothing on this browser and noise a released
|
|
one, so it is dropped, with one warning saying audio is rendered as stock."""
|
|
import warnings
|
|
|
|
with warnings.catch_warnings(record=True) as record:
|
|
warnings.simplefilter("always")
|
|
config = launch(config={"audio:seed": 9})
|
|
assert "audio:seed" not in config and config["fonts"]
|
|
[warning] = _removed_audio_warnings(record)
|
|
assert "rendered exactly as stock Firefox" in str(warning.message)
|
|
|
|
overrides = {"audio:seed": 7, "timezone": "Pacific/Chatham"}
|
|
with warnings.catch_warnings(record=True) as record:
|
|
warnings.simplefilter("always")
|
|
context = fp.generate_context_fingerprint(os="linux", config_overrides=overrides)
|
|
assert len(_removed_audio_warnings(record)) == 1
|
|
assert "audio:seed" not in context["config"]
|
|
assert context["config"]["timezone"] == "Pacific/Chatham"
|
|
assert overrides == {"audio:seed": 7, "timezone": "Pacific/Chatham"}, "the caller's dict was changed"
|
|
|
|
|
|
def test_no_canvas_seed_is_generated():
|
|
"""The browser adds no canvas noise (#528), and no patch reads canvas:seed
|
|
(#721). Generating one only sent the browser a value it ignored."""
|
|
assert "canvas:seed" not in launch()
|
|
context = fp.generate_context_fingerprint(os="linux")
|
|
assert "canvas:seed" not in context["config"]
|
|
assert "setCanvasSeed" not in context["init_script"]
|
|
|
|
|
|
class TestVoicesFollowLocale:
|
|
def test_windows_fr_identity_has_french_voices(self, monkeypatch):
|
|
for _ in range(5):
|
|
config = launch(os="windows", locale="fr-FR")
|
|
langs = {v["lang"] for v in config["voices"]}
|
|
assert "fr-FR" in langs, langs
|
|
|
|
|
|
class TestCoreCountFloor:
|
|
def test_small_pinnable_host_reports_table_floor(self, monkeypatch):
|
|
monkeypatch.setattr(cpu_affinity, "supported", lambda: True)
|
|
for host_cores in (1, 2, 3):
|
|
monkeypatch.setattr(fp, "host_cpu_count", lambda n=host_cores: n)
|
|
for drawn_cores in (1, 2, 3, 8):
|
|
c = {"navigator.hardwareConcurrency": drawn_cores}
|
|
fp.fix_hardware_concurrency(c)
|
|
assert c["navigator.hardwareConcurrency"] == 4, (host_cores, drawn_cores)
|
|
|
|
def test_unpinned_launch_reports_host(self, monkeypatch):
|
|
monkeypatch.setattr(cpu_affinity, "supported", lambda: True)
|
|
monkeypatch.setattr(fp, "host_cpu_count", lambda: 16)
|
|
c = {"navigator.hardwareConcurrency": 8}
|
|
fp.fix_hardware_concurrency(c, can_pin=False)
|
|
assert c["navigator.hardwareConcurrency"] == 16
|
|
|
|
def test_recorded_counts_are_in_the_table(self):
|
|
for n in (18, 22, 28, 32):
|
|
assert n in fp.PLAUSIBLE_CORE_COUNTS
|
|
|
|
|
|
class TestAffinityPick:
|
|
def test_adjacent_cores_from_a_random_start(self):
|
|
cores = list(range(16))
|
|
starts = set()
|
|
for _ in range(200):
|
|
picked = cpu_affinity._pick(cores, 4)
|
|
assert len(picked) == 4 and set(picked) <= set(cores)
|
|
ring = sorted(picked)
|
|
# adjacent modulo 16
|
|
assert any(all((s + i) % 16 in picked for i in range(4)) for s in ring)
|
|
starts.add(tuple(picked))
|
|
assert len(starts) > 4
|
|
|
|
|
|
class TestPrefsEnvIsAscii:
|
|
def test_non_ascii_pref_round_trips(self):
|
|
prefs = {"font.name.serif.ja": "游明朝", "intl.accept_languages": "fr-FR, fr"}
|
|
env = utils.get_pref_env_vars(prefs)
|
|
joined = "".join(env[f"CAMOU_PREFS_{i}"] for i in range(1, len(env) + 1))
|
|
assert joined.isascii()
|
|
assert orjson.loads(joined) == prefs
|
|
|
|
|
|
@pytest.mark.parametrize("off", [None, False])
|
|
def test_fingerprint_preset_off_never_draws_a_preset(off):
|
|
"""`fingerprint_preset=False` means off, the same as None. It used to be
|
|
checked with `is not None`, so False drew a random bundled preset."""
|
|
with mock.patch.object(utils, "get_random_preset", side_effect=AssertionError("preset drawn")):
|
|
launch(fingerprint_preset=off)
|
|
|
|
|
|
def test_no_glyph_spacing_seed_is_generated():
|
|
"""Glyph-spacing noise moved every measured text width off what the same
|
|
font gives on a real machine, so it was itself a fingerprint; the feature
|
|
is gone from the browser, and the launcher sends nothing for it."""
|
|
assert "fonts:spacing_seed" not in launch()
|
|
context = fp.generate_context_fingerprint(os="linux")
|
|
assert "fonts:spacing_seed" not in context["config"]
|
|
assert "setFontSpacingSeed" not in context["init_script"]
|
|
|
|
|
|
def test_config_overrides_reach_the_config_and_the_init_script():
|
|
context = fp.generate_context_fingerprint(
|
|
os="linux", config_overrides={"timezone": "Pacific/Chatham"}
|
|
)
|
|
assert context["config"]["timezone"] == "Pacific/Chatham"
|
|
assert "Pacific/Chatham" in context["init_script"]
|
|
|
|
|
|
def test_instant_animations_warn_that_they_are_detectable():
|
|
from camoufox._warnings import LeakWarning
|
|
|
|
with pytest.warns(LeakWarning, match="getComputedTiming"):
|
|
launch(config={"instantAnimations": True}, i_know_what_im_doing=False)
|
|
|
|
|
|
def test_is_mobile_warns_that_camoufox_is_desktop_only():
|
|
"""A persistent context takes its context options at launch."""
|
|
from camoufox._warnings import LeakWarning
|
|
|
|
with pytest.warns(LeakWarning, match="built for desktops"):
|
|
launch(is_mobile=True, i_know_what_im_doing=False)
|
|
|
|
|
|
def test_a_context_with_a_linux_ua_is_linux_throughout(monkeypatch):
|
|
"""fpgen's Linux pool now and then pairs the Linux UA with platform Win32 and
|
|
a Windows oscpu (~1.6% of NewContext Linux identities). launch_options()
|
|
fixed that and generate_context_fingerprint() did not -- and it reads the OS
|
|
for fonts and voices from the platform, so those came out Windows too."""
|
|
real = fp.generate_fingerprint
|
|
|
|
def mismatched(**kwargs):
|
|
drawn = real(**kwargs)
|
|
drawn["navigator"]["platform"] = "Win32"
|
|
drawn["navigator"]["oscpu"] = "Windows NT 10.0; Win64; x64"
|
|
return drawn
|
|
|
|
monkeypatch.setattr(fp, "generate_fingerprint", mismatched)
|
|
config = fp.generate_context_fingerprint(os="linux")["config"]
|
|
|
|
assert "Linux x86_64" in config["navigator.userAgent"]
|
|
assert config["navigator.platform"] == "Linux x86_64"
|
|
assert config["navigator.oscpu"] == "Linux x86_64"
|
|
assert "Segoe UI" not in config["fonts"]
|