The window.chrome object

A site that wants to know whether you are really running Chrome does not have to trust the name the browser gives itself. It can look for this object instead and see whether the two agree.

The window.chrome object is the set of Chrome specific properties a real Chrome leaves on every page it opens.

What sits behind the name

The object is a small handful of properties Chrome exposes for its own extensions and its own page timings. A page can use almost none of it and can see all of it.

A channel extensions talk through
Its messaging part is present on ordinary pages whether an extension is installed or not.
Two elderly timing helpers
Page load figures that predate the modern interface and that Chrome still carries for compatibility.
A leftover installation flag
A remnant of packaged web apps, still answered and still read by checks that know where to look.

Why a bot check looks for it

The reading takes one line and needs no permission. It is compared against the name the browser reports, and a disagreement between the two is cheap to find and hard to explain away.

The name says Chrome
Nearly every automated browser reports a Chrome name, because anything else is rarer still.
The object says otherwise
Builds meant for embedding and for testing frequently carry nothing of the sort.
The pair decides
Neither reading identifies a person. Together they separate a browser from something wearing its name.

The three ways this reading fails

A browser is caught here by carrying nothing, by carrying too little, or by carrying a shape no shipping Chrome ever had.

1
Nothing at all
The object is absent, and the browser has contradicted its own name in a single line.
2
An empty shell
The object exists with no messaging part, which is the shape a hurried patch leaves behind.
3
A shape from nowhere
Properties no released version carries are as loud as the absence they were meant to cover.

What our engine does

Our browser is compiled from the Chromium source, so this object is the browser's own rather than something laid over the page. Nothing has to keep a copy in step with the version the browser claims to be.

The self-test asks each profile for it, and on the acceptance run of the build shipping today it was there.

Present on the shipping build
Measured on a profile claiming one system while running on another, which is the case that matters.
present
Read beside the fields the hints give
The same run checks the platform, its version and the architecture a profile reports through client hints.
checked in one run
The built-in engine fills the gap
Where the app runs on a general purpose runtime instead of our build, the missing parts are supplied and the self-test still reports the result.
reported either way

Adding it late is weaker than having it

An object written by page code sits on top of the browser instead of inside it. The functions in it carry their own source, and a check can print that source in one line.

The source is printable
Any function can be asked to show itself, and a hand-written one shows exactly what was written.
A frame is a fresh page
Something added to one page is not added to a frame that page creates unless someone adds it again.
The shape keeps moving
Chrome changes what this object holds between releases, so a frozen copy ages into a mark of its own.

How to check your own

A browser console answers this in a single line, and that is the same line a check uses. What matters is not the answer by itself but whether it agrees with the name the browser reports.

Inside the app the self-test asks in a profile, against the engine that profile launched, and puts the answer next to the rest of the readings.

What this does not do

It does not tell two profiles apart. Every real Chrome carries this object, so nothing here makes one of your profiles look unrelated to another.
It does not account for what an extension adds. Code an extension loads into the page can reach this object, and a site reads whatever it finds.
It does not make a browser Chrome. Agreeing here is one reading among many, and the drawing surfaces carry far more weight than it does.
It does not answer for the browser you are reading this in. This page names a reading, and only a profile inside the app answers with the engine we ship.

Check it

Every claim above comes from a file you can open.

The self-test asks every profile for this object: apps/desktop/src/lib/fpAudit.js
What the built-in engine supplies when a runtime has none: apps/desktop/src/injected/fingerprint.js
The acceptance run of the build shipping today: engine/приёмка-отчёт.json
The self-test's own rules are tested too: apps/desktop/test/fp-audit.js

Questions

Can I see it myself?: Yes. Open the browser console on any page and ask for it by name: a real Chrome replies with an object rather than with nothing.
Do other browsers carry it?: Browsers built on the same source usually do, in their own shape. What a check compares is the object against the reported name, not the object against Chrome alone.
Does an extension change it?: It can. Code an extension puts into the page runs in the page, and whatever it leaves here is readable by the site.
Is a missing object enough to close an account?: On its own, rarely. It is cheap evidence that a session is not what it claims, and it is weighed together with the readings around it.
Why not simply add the object everywhere?: Because an addition made from the page is readable as an addition. Our engine carries the object because it is Chromium, which is a different fact about the same line.

Next to this

See what your own profile answers

The self-test runs inside a profile and shows all 29 measurements, green and red alike.

Download ARMANOS Fingerprint and its editor