CSS Fingerprint 2026

What CSS reveals about you without a single line of JavaScript

HOW IT WORKS

CSS-only exfiltration technique

CSS PROBES

Your browser loads a page with CSS rules containing conditional url() calls — no JavaScript runs

CONDITIONAL LOADING

@supports, @media, and container queries trigger HTTP requests only when conditions match

SERVER COLLECTION

The server logs which pixel URLs were requested — each hit reveals a feature bit

FINGERPRINT BUILD

Probe hits are assembled into a unique bitfield and hashed into your CSS fingerprint

The Fingerprint That Works Without JavaScript

The standard defense against browser fingerprinting was always "disable JavaScript." Run NoScript at "highest security." Use Tor Browser's most paranoid mode. JavaScript can't read your canvas if it can't run. Solid logic, until 2025. In 2025, researchers at CISPA Helmholtz published a paper titled "Sneaky Fingerprinting." They demonstrated 97.95% identification accuracy across 1,176 browser-OS combinations using zero JavaScript. CSS alone. The attack runs inside email clients, inside iframe previews, inside Markdown renderers, inside any context where a stylesheet gets parsed. NoScript doesn't stop it. Tor Browser mitigates but doesn't eliminate. Apple Mail and Thunderbird, with images enabled, are wide open. Sections below: how a stylesheet collects bits about your machine without executing a single line of code, why the math attack on subpixel arithmetic is genuinely clever, and why this changes what "blocking trackers" even means.

Anatomy of a Silent Fingerprint

The trick is conditional resource loading. CSS has three constructs that act like if-statements: `@supports`, `@media`, and container queries. Each tests a feature. Inside the matching rule, the attacker places a `background-image: url(/fp/feature-X.png)`. The browser fetches the image only if the condition matches. The server logs which URLs were requested. Done. A turnstile array for browsers, basically. Each conditional rule is a gate. Your browser walks through the ones it can pass. Each one clicks open and pings the server with an identifier. A typical fingerprinting stylesheet ships with 150 to 300 probes. Each probe maps to one bit: - `@supports (color: oklch(50% 0.1 100))`: does the browser have CSS Color 4? - `@media (resolution: 192dpi)`: is it a Retina display? - `@media (prefers-color-scheme: dark)`: dark mode active? - `@container (min-width: 10ch)`: font width measurement? - `@supports (font-tech(palettes))`: COLR-v1 fonts available? The browser quietly resolves each rule. Each match fires one HTTP GET. The server collects the bitfield in real time, hashes it, and now has a 256-bit identifier that survives clearing cookies, switching networks, and rotating proxies. The fingerprint depends on the browser's feature set and the OS's installed fonts. Both change slowly, often not at all between sessions. Total ask from the user: zero clicks, zero permissions, zero JavaScript. Just looking at the email or the page is enough.

Subpixel Arithmetic as a Tell

This is the part that should make any browser engineer wince. Modern CSS has math functions. `calc(sin(1) * 1000px + 500px)`. The result depends on how the browser's layout engine handles trigonometric precision and pixel rounding. Chrome's Blink uses one rounding path. Firefox's Gecko uses another. Safari's WebKit uses a third. The exact subpixel value at the end of that calculation differs by engine, sometimes by build version inside an engine. Now combine that with a container query at a fractional threshold: ``` @container (min-width: 1341.470984807897px) { body { background-image: url(/fp/math-precise); } } ``` The browser fetches that image only if its calc result rounds in a specific way. By placing dozens of these threshold checks at different fractional values, the attacker turns trigonometric precision into a fingerprint. The CISPA paper calls this the "Template Attack" when applied to system fonts: `font: menu`, `font: caption`, `font: status-bar` resolve to different fonts per OS, and `calc(10ch)` measures their average glyph width with subpixel precision. Result: the same browser version on Windows and macOS produces different bits because the OS pushes a different font into `font: caption`. The render engine handles the `ch` unit measurement deterministically, so the bit stays stable per OS. Cross-OS, it's a clean separator. Same logic as listening to a CPU's power draw to reconstruct an encryption key, except the surface is your browser's math. The information was always there. The spec faithfully exposes it. Nobody was listening until 2025.

The Old Playbook Doesn't Work Anymore

Three defense layers, ranked from worst to least bad. NoScript and JavaScript blockers do nothing against CSS fingerprinting. Their threat model assumed JS was the channel. CSS isn't. NoScript at "highest" security still parses stylesheets. The bits leak. Disabling images at the user agent level kills CSS fingerprinting completely. The browser doesn't fetch any URL, so no probes resolve. Side effect: roughly 80% of the modern web becomes unusable. Acceptable for email clients (Thunderbird's "Block remote content" handles this), unacceptable for everyday browsing. Tor Browser's approach is normalization. Window size locked, font set restricted to a fixed list, prefers-color-scheme reported the same for everyone, container query thresholds quantized. Most CSS probes return the same answer for every Tor user, which collapses the population. CISPA's paper confirms: Tor Browser users were identifiable across CSS bits, but the identification mostly resolved to "Tor user" rather than individual person. Imperfect but meaningful. For email specifically: turn off remote image loading. Thunderbird, Apple Mail, Outlook all support this. The CISPA paper documented 8 of 21 email clients as vulnerable to CSS fingerprinting via remote stylesheets. The other 13 already restrict CSS enough to break the attack. Default settings vary by client. "Load images only from senders in my contacts" is not enough. CSS can be inline and still fetch external resources via url(). The WHOX CSS fingerprint test runs the full CISPA probe set against your browser and surfaces the resulting bit pattern, the entropy estimate, and which specific feature combinations made you identifiable. Useful when you want to know whether your hardening actually closes the channel or just makes you feel better.

FREQUENTLY ASKED QUESTIONS

How does CSS fingerprinting work without JavaScript?

CSS can conditionally load resources using @supports, @media, and container queries. When a CSS rule matches, the browser automatically requests a background-image URL. The server logs which URLs were fetched, building a fingerprint from the pattern of supported features.

Is CSS fingerprinting a real threat?

Yes. Researchers at CISPA Helmholtz demonstrated 97.95% accuracy across 1,176 browser-OS combinations using only CSS. This technique works even in email clients where JavaScript is blocked, affecting Thunderbird, Apple Mail, Samsung Email, and others.

Can I protect myself from CSS fingerprinting?

Unlike JavaScript fingerprinting, there's no simple defense. Disabling CSS breaks all websites. The Tor Browser mitigates this somewhat by normalizing browser features, but CSS fingerprinting remains extremely difficult to block completely.

All our tests

Run the full WHOX toolkit from one place: leak checks, fingerprint probes, network diagnostics, reputation lookups, and privacy failure tests.