use anyhow::{anyhow, Result};
use runtime_foxdriver::Page;
use serde::{de::IntoDeserializer, Deserialize, Serialize};
mod js;
pub(crate) use js::*;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FingerprintConfig {
#[serde(default = "default_canvas_noise")]
pub canvas_noise: f64,
#[serde(default)]
pub webgl_override: bool,
#[serde(default = "default_true")]
pub audio_noise: bool,
#[serde(default = "default_true")]
pub font_noise: bool,
#[serde(default)]
pub performance_noise: bool,
#[serde(default)]
pub hardware_concurrency: Option<u8>,
#[serde(default)]
pub device_memory: Option<u8>,
#[serde(default)]
pub seed: Option<u64>,
}
fn default_canvas_noise() -> f64 {
0.02
}
fn default_true() -> bool {
true
}
impl Default for FingerprintConfig {
fn default() -> Self {
Self {
canvas_noise: 0.02,
webgl_override: true,
audio_noise: true,
font_noise: true,
performance_noise: false,
hardware_concurrency: None,
device_memory: None,
seed: None,
}
}
}
impl FingerprintConfig {
pub fn minimal() -> Self {
Self {
canvas_noise: 0.01,
webgl_override: false,
audio_noise: false,
font_noise: false,
performance_noise: false,
hardware_concurrency: None,
device_memory: None,
seed: None,
}
}
pub fn maximum() -> Self {
Self {
canvas_noise: 0.05,
webgl_override: true,
audio_noise: true,
font_noise: true,
performance_noise: true,
hardware_concurrency: Some(8),
device_memory: Some(8),
seed: None,
}
}
}
pub fn evasion_js_source(config: &FingerprintConfig) -> String {
let seed = config.seed.unwrap_or_else(rand::random::<u64>);
let seed32 = (seed & u64::from(u32::MAX)) as u32;
let mut scripts = Vec::new();
let canvas_noise = normalized_canvas_noise(config.canvas_noise);
if canvas_noise > 0.0 {
scripts.push(canvas_noise_js(seed32, canvas_noise));
}
if config.audio_noise {
scripts.push(audio_noise_js(seed32));
}
if config.font_noise {
scripts.push(font_noise_js(seed32));
}
if config.performance_noise {
scripts.push(performance_noise_js(seed32));
}
if let Some(cores) = config.hardware_concurrency {
scripts.push(hardware_concurrency_js(cores.clamp(1, 64)));
}
if let Some(mem) = config.device_memory {
scripts.push(device_memory_js(mem.clamp(1, 64)));
}
if config.webgl_override {
scripts.push(webgl_shape_js());
}
if scripts.is_empty() {
return String::new();
}
format!("{}\n{};\n", super::NATIVE_SEAL_PRELUDE, scripts.join(";\n"))
}
pub async fn apply_fingerprint(page: &Page, config: &FingerprintConfig) -> Result<()> {
let script = evasion_js_source(config);
if script.trim().is_empty() {
return Ok(());
}
page.add_preload_script(&script)
.await
.map_err(|e| anyhow!("stealth fingerprint evasion injection failed: {e}"))?;
Ok(())
}
pub async fn collect_signals(page: &Page) -> Result<FingerprintSignals> {
let js = r#"(function() {
const signals = {};
try {
const canvas = document.createElement('canvas');
canvas.width = 200;
canvas.height = 50;
const ctx = canvas.getContext('2d');
ctx.textBaseline = 'top';
ctx.font = '14px Arial';
ctx.fillText('fingerprint test', 2, 2);
signals.canvas_hash = canvas.toDataURL().length;
} catch(e) { signals.canvas_hash = -1; }
try {
const gl = document.createElement('canvas').getContext('webgl');
const ext = gl && gl.getExtension('WEBGL_debug_renderer_info');
signals.webgl_vendor = ext ? gl.getParameter(ext.UNMASKED_VENDOR_WEBGL) : 'unknown';
signals.webgl_renderer = ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : 'unknown';
} catch(e) {
signals.webgl_vendor = 'error';
signals.webgl_renderer = 'error';
}
signals.user_agent = navigator.userAgent;
signals.platform = navigator.platform;
signals.language = navigator.language;
signals.languages = navigator.languages ? Array.from(navigator.languages) : [];
signals.hardware_concurrency = navigator.hardwareConcurrency || 0;
signals.device_memory = navigator.deviceMemory || 0;
signals.do_not_track = navigator.doNotTrack;
signals.screen_width = screen.width;
signals.screen_height = screen.height;
signals.color_depth = screen.colorDepth;
signals.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
return signals;
})()"#;
let result = page.evaluate(js).await?;
let val: serde_json::Value = result.into_value().map_err(|e| {
anyhow!("fingerprint-signal probe returned a result that did not deserialize as JSON: {e}")
})?;
parse_fingerprint_signals(val)
}
fn parse_fingerprint_signals(value: serde_json::Value) -> Result<FingerprintSignals> {
let de = value.into_deserializer();
match serde_path_to_error::deserialize::<_, FingerprintSignals>(de) {
Ok(signals) => Ok(signals),
Err(e) => Err(anyhow!(
"fingerprint-signal probe returned a JSON value that does not match FingerprintSignals at `{}`: {}",
e.path(),
e.inner()
)),
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FingerprintSignals {
pub canvas_hash: i64,
pub webgl_vendor: String,
pub webgl_renderer: String,
pub user_agent: String,
pub platform: String,
pub language: String,
pub hardware_concurrency: u8,
pub device_memory: u8,
pub screen_width: u32,
pub screen_height: u32,
pub color_depth: u8,
pub timezone: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_config() {
let cfg = FingerprintConfig::default();
assert!((cfg.canvas_noise - 0.02).abs() < 0.001);
assert!(cfg.webgl_override);
assert!(cfg.audio_noise);
assert!(cfg.font_noise);
}
#[test]
fn minimal_config() {
let cfg = FingerprintConfig::minimal();
assert!((cfg.canvas_noise - 0.01).abs() < 0.001);
assert!(!cfg.webgl_override);
assert!(!cfg.audio_noise);
}
#[test]
fn maximum_config() {
let cfg = FingerprintConfig::maximum();
assert!(cfg.performance_noise);
assert_eq!(cfg.hardware_concurrency, Some(8));
assert_eq!(cfg.device_memory, Some(8));
}
#[test]
fn config_serde() {
let cfg = FingerprintConfig::default();
let json = serde_json::to_string(&cfg).unwrap();
let restored: FingerprintConfig = serde_json::from_str(&json).unwrap();
assert!((restored.canvas_noise - cfg.canvas_noise).abs() < 0.001);
}
#[test]
fn signals_serde() {
let signals = FingerprintSignals {
canvas_hash: 12345,
webgl_vendor: "Google Inc. (NVIDIA)".into(),
webgl_renderer: "ANGLE (NVIDIA, GeForce RTX 3060)".into(),
user_agent: "Mozilla/5.0 Chrome/131".into(),
platform: "Win32".into(),
language: "en-US".into(),
hardware_concurrency: 12,
device_memory: 16,
screen_width: 1920,
screen_height: 1080,
color_depth: 24,
timezone: "America/New_York".into(),
};
let json = serde_json::to_string(&signals).unwrap();
let restored: FingerprintSignals = serde_json::from_str(&json).unwrap();
assert_eq!(restored.canvas_hash, 12345);
assert_eq!(restored.hardware_concurrency, 12);
}
#[test]
fn config_from_json_with_defaults() {
let json = r#"{"canvas_noise": 0.1}"#;
let cfg: FingerprintConfig = serde_json::from_str(json).unwrap();
assert!((cfg.canvas_noise - 0.1).abs() < 0.001);
assert!(cfg.audio_noise);
assert!(cfg.font_noise);
}
#[test]
fn evasion_js_default_covers_configured_surfaces() {
let cfg = FingerprintConfig {
seed: Some(42),
..FingerprintConfig::default()
};
let js = evasion_js_source(&cfg);
for needle in [
"HTMLCanvasElement.prototype.toDataURL",
"HTMLCanvasElement.prototype.toBlob",
"CanvasRenderingContext2D.prototype.getImageData",
"OffscreenCanvasRenderingContext2D.prototype.getImageData",
"measureText",
"AudioBuffer.prototype.getChannelData",
"AnalyserNode.prototype",
"WebGLRenderingContext",
"getSupportedExtensions",
] {
assert!(js.contains(needle), "missing {needle}");
}
assert!(
!js.contains("getShaderPrecisionFormat"),
"getShaderPrecisionFormat must stay native (pass-through), not be patched: {js}"
);
}
#[test]
fn evasion_js_minimal_skips_disabled_surfaces() {
let cfg = FingerprintConfig {
seed: Some(42),
..FingerprintConfig::minimal()
};
let js = evasion_js_source(&cfg);
assert!(js.contains("HTMLCanvasElement.prototype.toDataURL"));
assert!(!js.contains("getChannelData"));
assert!(!js.contains("measureText"));
assert!(!js.contains("WebGLRenderingContext"));
}
#[test]
fn evasion_js_does_not_reimplement_engine_or_identity_surfaces() {
let cfg = FingerprintConfig {
seed: Some(42),
..FingerprintConfig::default()
};
let js = evasion_js_source(&cfg);
for forbidden in [
"navigator.userAgent",
"navigator.platform",
"navigator.languages",
"navigator.webdriver",
"screen.width",
"screen.height",
] {
assert!(
!js.contains(forbidden),
"evasion JS must not reimplement identity/engine surface {forbidden}"
);
}
}
#[test]
fn evasion_js_clamps_untrusted_numeric_inputs() {
let cfg = FingerprintConfig {
canvas_noise: f64::NAN,
audio_noise: false,
font_noise: false,
performance_noise: false,
webgl_override: false,
hardware_concurrency: Some(255),
device_memory: Some(0),
seed: Some(42),
};
let js = evasion_js_source(&cfg);
assert!(!js.contains("HTMLCanvasElement.prototype.toDataURL"));
assert!(js.contains("get: __seal(() => 64, 'get hardwareConcurrency')"));
assert!(js.contains("get: __seal(() => 1, 'get deviceMemory')"));
}
#[test]
fn parse_fingerprint_signals_accepts_complete_json() {
let val = serde_json::json!({
"canvas_hash": 12345,
"webgl_vendor": "Google Inc. (NVIDIA)",
"webgl_renderer": "ANGLE (NVIDIA, GeForce RTX 3060)",
"user_agent": "Mozilla/5.0 Chrome/131",
"platform": "Win32",
"language": "en-US",
"hardware_concurrency": 12,
"device_memory": 16,
"screen_width": 1920,
"screen_height": 1080,
"color_depth": 24,
"timezone": "America/New_York"
});
let signals = parse_fingerprint_signals(val).unwrap();
assert_eq!(signals.canvas_hash, 12345);
assert_eq!(signals.webgl_vendor, "Google Inc. (NVIDIA)");
assert_eq!(signals.hardware_concurrency, 12);
assert_eq!(signals.screen_width, 1920);
assert_eq!(signals.timezone, "America/New_York");
}
#[test]
fn parse_fingerprint_signals_rejects_missing_field() {
let val = serde_json::json!({
"canvas_hash": 12345
});
let err = parse_fingerprint_signals(val).unwrap_err().to_string();
assert!(
err.contains("missing field") || err.contains("FingerprintSignals"),
"{err}"
);
}
#[test]
fn parse_fingerprint_signals_rejects_wrong_type() {
let val = serde_json::json!({
"canvas_hash": 12345,
"webgl_vendor": "Google Inc. (NVIDIA)",
"webgl_renderer": "ANGLE (NVIDIA, GeForce RTX 3060)",
"user_agent": "Mozilla/5.0 Chrome/131",
"platform": "Win32",
"language": "en-US",
"hardware_concurrency": "twelve",
"device_memory": 16,
"screen_width": 1920,
"screen_height": 1080,
"color_depth": 24,
"timezone": "America/New_York"
});
let err = parse_fingerprint_signals(val).unwrap_err().to_string();
assert!(err.contains("hardware_concurrency"), "{err}");
}
#[test]
fn parse_fingerprint_signals_rejects_out_of_range_u8() {
let val = serde_json::json!({
"canvas_hash": 12345,
"webgl_vendor": "Google Inc. (NVIDIA)",
"webgl_renderer": "ANGLE (NVIDIA, GeForce RTX 3060)",
"user_agent": "Mozilla/5.0 Chrome/131",
"platform": "Win32",
"language": "en-US",
"hardware_concurrency": 300,
"device_memory": 16,
"screen_width": 1920,
"screen_height": 1080,
"color_depth": 24,
"timezone": "America/New_York"
});
let err = parse_fingerprint_signals(val).unwrap_err().to_string();
assert!(
err.contains("hardware_concurrency") || err.contains("integer") || err.contains("u8"),
"{err}"
);
}
}