use anyhow::{anyhow, Result};
use futures::future::join_all;
use runtime_foxdriver::Page;
pub use guise_oracle::{
severity_rank, Capture, CapturedSurface, Determinism, DifferentialReport, Divergence,
DivergenceKind, DriftReport, Probe, ProbeOutcome, ProbeReport, Severity, ThreeWayReport,
ThreeWaySurface,
};
mod behavioral;
mod bidi_tells;
mod catalogue;
mod catalogue_extended;
mod catalogue_firefox;
mod catalogue_misc;
mod classify;
mod codec;
mod completeness;
mod creepjs;
mod drift;
mod fixture;
mod lie_detector;
mod oracle;
mod realm;
mod redteam;
pub mod scorecard;
pub mod surface_coverage;
#[cfg(test)]
mod tests;
#[cfg(feature = "http-headers")]
mod transport;
pub use behavioral::{
behavioral_capture, compute_behavioral_fingerprint,
enrich_capture as enrich_capture_behavioral, BehavioralFingerprint,
};
pub use catalogue::{probes, probes_for};
pub use completeness::{
all_gaps, coverage_report, CheckCriticality, CoverageGap, CoverageReport, KnownCheck,
KNOWN_FINGERPRINTER_CHECKS,
};
pub use drift::{BisectReport, DriftDetector, DriftEvent, DriftSnapshot, Layer, PersonaContext};
pub use fixture::synthetic_firefox_fixture;
pub use guise_profiles::UserAgentBrowser;
pub use oracle::{
capture_page, diff_captures, diff_pages, full_stack_compare, render_differential,
render_three_way, three_way_compare, FullStackReport,
};
pub use realm::worker_realm_is_self_coherent;
pub use scorecard::{scorecard_from_report, Scorecard, ScorecardEntry, ScorecardSurface};
pub use surface_coverage::{
category_for_probe, divergence_kind_for_probe, persona_overridden_surface_ids,
spoofed_surface_ids, surface_coverage, NoiseSpoofLink, ProbeSurfaceLink, SpoofSurfaceLink,
SurfaceCoverage, NOISE_SPOOF_LINKS, PROBE_SURFACE_LINKS, SPOOF_SURFACE_LINKS,
};
#[cfg(feature = "http-headers")]
pub use transport::{
compute_transport_fingerprint, enrich_capture as enrich_capture_transport, transport_capture,
transport_suggests_linux_persona, TransportFingerprint,
};
pub const PROBE_COUNT_FLOOR: usize = 200;
pub async fn run(page: &Page) -> Result<DriftReport> {
run_for(page, UserAgentBrowser::Chrome).await
}
pub async fn run_for(page: &Page, browser: UserAgentBrowser) -> Result<DriftReport> {
let catalogue = probes_for(browser);
let mut work = Vec::with_capacity(catalogue.len());
for probe in catalogue {
let js = probe.js;
let name = probe.name.to_string();
let severity = probe.severity;
let classifier = probe.classifier;
work.push(async move {
let outcome = match page.evaluate_await(js).await {
Ok(eval) => match eval.into_value::<serde_json::Value>() {
Ok(value) => classifier(&value),
Err(e) => ProbeOutcome::ProbeError(format!(
"probe result did not deserialize as JSON: {e}"
)),
},
Err(e) => ProbeOutcome::ProbeError(e.to_string()),
};
ProbeReport {
name,
severity: format!("{:?}", severity),
outcome,
}
});
}
let reports = join_all(work).await;
let probed = reports.len();
let mut passed = 0usize;
let mut drift = 0usize;
let mut critical = 0usize;
let mut probe_errors = 0usize;
for r in &reports {
match &r.outcome {
ProbeOutcome::Pass => passed += 1,
ProbeOutcome::Drift(_) => drift += 1,
ProbeOutcome::Critical(_) => critical += 1,
ProbeOutcome::ProbeError(_) => probe_errors += 1,
}
}
Ok(DriftReport {
probed,
passed,
drift,
critical,
probe_errors,
per_probe: reports,
})
}
pub fn render_report(report: &DriftReport) -> String {
use std::fmt::Write;
let mut out = String::with_capacity(report.per_probe.len() * 120);
let _ = writeln!(out, "STEALTH PROBE - {}", report.summary());
let _ = writeln!(out, "{:-^100}", "");
for r in &report.per_probe {
let icon = match &r.outcome {
ProbeOutcome::Pass => "✓",
ProbeOutcome::Drift(_) => "~",
ProbeOutcome::Critical(_) => "✘",
ProbeOutcome::ProbeError(_) => "?",
};
let detail = match &r.outcome {
ProbeOutcome::Pass => String::new(),
ProbeOutcome::Drift(m) | ProbeOutcome::Critical(m) | ProbeOutcome::ProbeError(m) => {
format!(" - {m}")
}
};
let _ = writeln!(out, " {icon} [{}] {}{}", r.severity, r.name, detail);
}
out
}
pub async fn audit_page(page: &Page) -> Result<DriftReport> {
audit_page_for(page, UserAgentBrowser::Chrome).await
}
pub async fn audit_page_for(page: &Page, browser: UserAgentBrowser) -> Result<DriftReport> {
let r = run_for(page, browser)
.await
.map_err(|e| anyhow!("probe run failed: {e}"))?;
Ok(r)
}
#[cfg(test)]
mod into_value_no_swallow_audit {
use std::fs;
use std::path::{Path, PathBuf};
fn rs_files(dir: &Path, out: &mut Vec<PathBuf>) {
let Ok(entries) = fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let p = entry.path();
if p.is_dir() {
rs_files(&p, out);
} else if p.extension().and_then(|e| e.to_str()) == Some("rs") {
out.push(p);
}
}
}
fn is_full_line_comment(line: &str) -> bool {
line.trim_start().starts_with("//")
}
#[test]
fn into_value_reads_never_swallow_a_deserialize_failure() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let mut files = Vec::new();
rs_files(&root.join("src"), &mut files);
let read_token = concat!("into_", "value");
let swallow_tokens = [concat!("unwrap", "_or"), concat!(".ok", "()")];
let mut scanned = 0usize;
for f in &files {
let Ok(src) = fs::read_to_string(f) else {
continue;
};
for (idx, line) in src.lines().enumerate() {
if is_full_line_comment(line) || !line.contains(read_token) {
continue;
}
scanned += 1;
if let Some(swallow) = swallow_tokens.iter().find(|t| line.contains(*t)) {
panic!(
"{}:{}: an `into_value` read-back is paired with the result-swallowing \
token {swallow:?} (Law 10 / G261). A swallowed deserialize coerces a failed \
probe read into a clean value, which classifiers and the differential oracle \
score as a false PASS / false agreement. Surface it (match / map_err(...)? \
to an error cell or ProbeError), never a swallow. Line: {}",
f.display(),
idx + 1,
line.trim()
);
}
}
}
assert!(
scanned >= 3,
"into_value audit matched only {scanned} read-back sites, the token drifted from \
the real source and the guard is now inert"
);
}
}