mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
Found in review of the previous commits: - identity_seed() hashed 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. The seed now mixes in identity_salt(): derived from what the caller pinned the identity with (a Fingerprint, a preset dict, a config naming the UA) so relaunching that identity reproduces every draw, and random otherwise. A pinned preset now reproduces its noise seeds too; seeds the caller sets are kept. - Concurrent AsyncNewBrowser launches on one driver interleaved pin/restore: one browser inherited the other's mask and the driver could stay pinned. pin -> launch -> restore is serialized per driver. - Every pinned browser landed on cores 0..N-1; pins now take N adjacent cores from a random start. - A pinnable host with 1-3 cores reported 1, 2 or 3 (2 is the resistFingerprinting value); the table floor of 4 applies as on other hosts. - launch_options() callers that launch the browser themselves (launch_server, direct use) kept the drawn core count although nothing pins the browser; only Camoufox/AsyncCamoufox pass pin_cpu_cores=True now, everyone else reports the host's snapped count. - PLAUSIBLE_CORE_COUNTS gains 18, 22, 28 and 32, all recorded in the -v150 corpus. - The Windows voice list was drawn before the locale was resolved, so an fr-FR identity got en-US voices; it is drawn after locale/geoip now. - macOS "Alex" gets its com.apple.speech.synthesis.voice identifier. - CAMOU_PREFS env chunks are ASCII-only JSON (Windows getenv goes through the ANSI code page). Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
250 lines
9.1 KiB
Python
250 lines
9.1 KiB
Python
import asyncio
|
|
import json as _json
|
|
import urllib.request
|
|
from functools import partial
|
|
from typing import Any, Dict, List, Optional, Union, overload
|
|
from urllib.parse import urlparse
|
|
|
|
from playwright.async_api import (
|
|
Browser,
|
|
BrowserContext,
|
|
Playwright,
|
|
PlaywrightContextManager,
|
|
)
|
|
from typing_extensions import Literal
|
|
|
|
from camoufox.virtdisplay import VirtualDisplay
|
|
|
|
from .fingerprints import generate_context_fingerprint
|
|
from .utils import (
|
|
async_attach_vd,
|
|
attach_no_viewport_default,
|
|
launch_options,
|
|
spoofs_window_dimensions,
|
|
)
|
|
|
|
|
|
class AsyncCamoufox(PlaywrightContextManager):
|
|
"""
|
|
Wrapper around playwright.async_api.PlaywrightContextManager that automatically
|
|
launches a browser and closes it when the context manager is exited.
|
|
"""
|
|
|
|
def __init__(self, **launch_options):
|
|
super().__init__()
|
|
self.launch_options = launch_options
|
|
self.browser: Optional[Union[Browser, BrowserContext]] = None
|
|
|
|
async def __aenter__(self) -> Union[Browser, BrowserContext]:
|
|
_playwright = await super().__aenter__()
|
|
try:
|
|
self.browser = await AsyncNewBrowser(_playwright, **self.launch_options)
|
|
except BaseException as e:
|
|
# Any launch failure (InvalidProxy, missing browser, bad options, ...)
|
|
# must tear down the playwright session started above so the driver
|
|
# process/connection is not leaked.
|
|
await super().__aexit__(type(e), e, e.__traceback__)
|
|
raise
|
|
return self.browser
|
|
|
|
async def __aexit__(self, *args: Any):
|
|
# Run the base teardown even if browser.close() raises (e.g. the browser
|
|
# process already crashed), so the playwright driver/connection is not leaked.
|
|
try:
|
|
if self.browser:
|
|
await self.browser.close()
|
|
finally:
|
|
await super().__aexit__(*args)
|
|
|
|
|
|
@overload
|
|
async def AsyncNewBrowser(
|
|
playwright: Playwright,
|
|
*,
|
|
from_options: Optional[Dict[str, Any]] = None,
|
|
persistent_context: Literal[False] = False,
|
|
**kwargs,
|
|
) -> Browser: ...
|
|
|
|
|
|
@overload
|
|
async def AsyncNewBrowser(
|
|
playwright: Playwright,
|
|
*,
|
|
from_options: Optional[Dict[str, Any]] = None,
|
|
persistent_context: Literal[True],
|
|
**kwargs,
|
|
) -> BrowserContext: ...
|
|
|
|
|
|
async def AsyncNewBrowser(
|
|
playwright: Playwright,
|
|
*,
|
|
headless: Optional[Union[bool, Literal['virtual']]] = None,
|
|
from_options: Optional[Dict[str, Any]] = None,
|
|
persistent_context: bool = False,
|
|
debug: Optional[bool] = None,
|
|
**kwargs,
|
|
) -> Union[Browser, BrowserContext]:
|
|
"""
|
|
Launches a new browser instance for Camoufox given a set of launch options.
|
|
|
|
Parameters:
|
|
from_options (Dict[str, Any]):
|
|
A set of launch options generated by `launch_options()` to use
|
|
persistent_context (bool):
|
|
Whether to use a persistent context.
|
|
**kwargs:
|
|
All other keyword arugments passed to `launch_options()`.
|
|
"""
|
|
if headless == 'virtual':
|
|
virtual_display = VirtualDisplay(debug=debug)
|
|
kwargs['virtual_display'] = virtual_display.get()
|
|
headless = False
|
|
else:
|
|
virtual_display = None
|
|
|
|
if not from_options:
|
|
kwargs.setdefault('pin_cpu_cores', True)
|
|
from_options = await asyncio.get_event_loop().run_in_executor(
|
|
None,
|
|
partial(launch_options, headless=headless, debug=debug, **kwargs),
|
|
)
|
|
|
|
# Playwright's default viewport deadlocks Juggler when the window is spoofed
|
|
# to a different size (daijro/camoufox#666), so default to no_viewport.
|
|
no_viewport_default = spoofs_window_dimensions(from_options)
|
|
|
|
# Pin the driver (and so the browser it is about to spawn) to as many
|
|
# cores as the identity reports, so measurable parallelism matches
|
|
# navigator.hardwareConcurrency; the driver gets its cores back afterwards.
|
|
from . import cpu_affinity
|
|
from .utils import driver_pid, pinned_core_count
|
|
|
|
pin_to = pinned_core_count(from_options)
|
|
pid = driver_pid(playwright) if pin_to else None
|
|
if not pid:
|
|
return await _launch(playwright, from_options, persistent_context, no_viewport_default, virtual_display)
|
|
# The browser inherits the driver's mask at spawn, so two concurrent launches
|
|
# on one driver must not interleave pin/restore: the second pin would land on
|
|
# the first browser, and the first restore would leave the driver pinned.
|
|
async with _pin_lock(pid):
|
|
previous = cpu_affinity.pin(pid, pin_to)
|
|
try:
|
|
return await _launch(playwright, from_options, persistent_context, no_viewport_default, virtual_display)
|
|
finally:
|
|
cpu_affinity.restore(pid, previous)
|
|
|
|
|
|
_PIN_LOCKS: Dict[int, asyncio.Lock] = {}
|
|
|
|
|
|
def _pin_lock(pid: int) -> asyncio.Lock:
|
|
# One lock per driver: a driver belongs to one event loop.
|
|
lock = _PIN_LOCKS.get(pid)
|
|
if lock is None:
|
|
lock = _PIN_LOCKS[pid] = asyncio.Lock()
|
|
return lock
|
|
|
|
|
|
async def _launch(
|
|
playwright: Playwright,
|
|
from_options: Dict[str, Any],
|
|
persistent_context: bool,
|
|
no_viewport_default: bool,
|
|
virtual_display: Optional[VirtualDisplay],
|
|
) -> Union[Browser, BrowserContext]:
|
|
# Persistent context
|
|
if persistent_context:
|
|
if no_viewport_default and not ('viewport' in from_options or 'no_viewport' in from_options):
|
|
from_options = {**from_options, 'no_viewport': True}
|
|
context = await playwright.firefox.launch_persistent_context(**from_options)
|
|
return await async_attach_vd(context, virtual_display)
|
|
|
|
# Browser
|
|
browser = await playwright.firefox.launch(**from_options)
|
|
if no_viewport_default:
|
|
attach_no_viewport_default(browser)
|
|
return await async_attach_vd(browser, virtual_display)
|
|
|
|
|
|
def _proxy_url_with_creds(proxy: Dict[str, str]) -> str:
|
|
"""Builds a proxy URL string with embedded credentials."""
|
|
parsed = urlparse(proxy.get("server", ""))
|
|
user = proxy.get("username", "")
|
|
pwd = proxy.get("password", "")
|
|
if user and pwd:
|
|
return f"{parsed.scheme}://{user}:{pwd}@{parsed.netloc}"
|
|
return proxy.get("server", "")
|
|
|
|
|
|
async def _resolve_proxy_geo(proxy: Dict[str, str]) -> Dict[str, Optional[str]]:
|
|
"""Queries ip-api.com through the proxy for the exit IP and timezone."""
|
|
proxy_url = _proxy_url_with_creds(proxy)
|
|
|
|
def _fetch() -> Dict[str, Optional[str]]:
|
|
handler = urllib.request.ProxyHandler({"http": proxy_url, "https": proxy_url})
|
|
opener = urllib.request.build_opener(handler)
|
|
try:
|
|
with opener.open("http://ip-api.com/json?fields=query,timezone", timeout=10) as resp:
|
|
data = _json.loads(resp.read())
|
|
return {"ip": data.get("query") or None, "timezone": data.get("timezone") or None}
|
|
except Exception:
|
|
return {"ip": None, "timezone": None}
|
|
|
|
return await asyncio.get_event_loop().run_in_executor(None, _fetch)
|
|
|
|
|
|
async def AsyncNewContext(
|
|
browser: Browser,
|
|
*,
|
|
preset: Optional[Dict[str, Any]] = None,
|
|
os: Optional[str] = None,
|
|
ff_version: Optional[str] = None,
|
|
webrtc_ip: Optional[str] = None,
|
|
proxy: Optional[Dict[str, str]] = None,
|
|
geolocation: Optional[Dict[str, float]] = None,
|
|
**context_kwargs: Any,
|
|
) -> BrowserContext:
|
|
"""
|
|
Creates a new browser context with a unique fingerprint identity.
|
|
|
|
Each context gets its own real fingerprint preset (navigator, screen, WebGL, fonts, etc.)
|
|
with unique seeds for audio, canvas, and font spacing noise. All values are applied
|
|
via addInitScript so they self-destruct before page scripts can detect them.
|
|
|
|
Parameters:
|
|
browser: A Browser instance from AsyncNewBrowser or AsyncCamoufox.
|
|
preset: A specific fingerprint preset dict to use. If None, picks randomly.
|
|
os: Target OS for preset selection ("windows", "macos", "linux").
|
|
ff_version: Firefox version string for UA patching.
|
|
webrtc_ip: IPv4 address to spoof for WebRTC ICE candidates.
|
|
proxy: Per-context proxy (Playwright format: {"server": "...", "username": "...", "password": "..."}).
|
|
geolocation: Per-context geolocation ({"latitude": float, "longitude": float}).
|
|
**context_kwargs: Additional Playwright new_context() options.
|
|
"""
|
|
# Auto-derive WebRTC IP and timezone from proxy's exit IP when not explicitly provided
|
|
if proxy and (not webrtc_ip or "timezone_id" not in context_kwargs):
|
|
geo = await _resolve_proxy_geo(proxy)
|
|
if not webrtc_ip:
|
|
webrtc_ip = geo["ip"]
|
|
if "timezone_id" not in context_kwargs and geo["timezone"]:
|
|
context_kwargs["timezone_id"] = geo["timezone"]
|
|
|
|
fp = await asyncio.get_event_loop().run_in_executor(
|
|
None,
|
|
lambda: generate_context_fingerprint(preset=preset, os=os, ff_version=ff_version, webrtc_ip=webrtc_ip),
|
|
)
|
|
|
|
# Merge generated context options with user overrides (user wins)
|
|
opts: Dict[str, Any] = {**fp['context_options'], **context_kwargs}
|
|
if proxy:
|
|
opts['proxy'] = proxy
|
|
if geolocation:
|
|
opts['geolocation'] = geolocation
|
|
opts.setdefault('permissions', ['geolocation'])
|
|
|
|
context = await browser.new_context(**opts)
|
|
await context.add_init_script(fp['init_script'])
|
|
return context
|