Canvas noise

A drawing is made of channel values, four bytes to a pixel. Noise adds a small offset to those bytes, and the offset is derived from the seed of the profile rather than drawn fresh each time.

The seed is what makes the result repeatable. One profile answers itself the same way on every visit, and two profiles answer differently.

1. 1

   The page draws as usual

   Text, shapes and colours land on an off screen canvas that is never shown. No permission is asked, because nothing here counts as private to the browser.

2. 2

   The offsets go on

   Each channel moves by a small amount decided by the seed. The offset belongs to the pixel, not to its position in the buffer handed back.

3. 3

   The page reads the result

   The bytes come back shifted, and the hash the site stores is a different one. The picture itself is still a picture and still reads as one.

These values are read in your browser on this page. The hash is what a site would store about this machine.

Nothing here leaves this page. The reading is drawn on the spot, and a checker that sends your hash somewhere has already collected it.

Adding an offset is easy. Adding it where a second look cannot find it is the whole job, and four placements fail that test.

A real machine never disagrees with itself. Every failure below is a browser contradicting its own answer, which is louder than any unusual value.

• Offsets tied to the buffer

  If the offset follows the position in the returned array rather than the pixel, the same strip read through two windows disagrees with itself.

• Offsets ignoring transparency

  Colour under full transparency carries no meaning, and no real driver produces it. A site can test for it in three lines.

• Offsets that never change

  A mask learned from a solid fill can be subtracted from any other drawing. At that point the defence has become the mark it was meant to hide.

• Offsets written over the page

  A wrapper around a read function has to look native to anything that inspects it. The self-test puts that question to the graphics reader and to the webdriver flag.

All four placements are measured on our own engine, over every seed the run is given. The numbers below come from the run of 2 September.

Each is one line in the invariant harness. A build that answers otherwise is not accepted, and that rule is code rather than a habit, so a rebuild cannot quietly lose it.

• One pixel through two windows

  The same strip read twice through different rectangles comes back with the same bytes.

  0 bytes

• The mask does not carry over

  Offsets learned from a solid fill do not transfer to a different drawing on any of the seeds.

  0 of 7

• Two profiles draw apart

  One picture drawn in two profiles gives two hashes, so the offsets are seeded rather than shared.

  2 hashes

The offsets are applied where the pixels are made, not where they are handed back, and they come from the profile seed. That is why one profile is stable to itself while two profiles are unrelated.

Two runs of the same invariant harness: the build before the fingerprint patches, and the build shipping today. The harness is the same file in both columns.

• Blocking canvas

  A browser that answers with a blank image is rarer than any particular drawing. Refusing turns into the identifying trait.

• A fresh value per read

  Two reads in one session that disagree are a contradiction inside one browser. Stability to itself is a requirement, not a shortcut.

• Canvas fingerprint

  The fingerprint is what a site computes, the noise is what moves it. Naming one for the other hides which side is being measured.

• WebGL noise

  The graphics surface is drawn by the card and read through its own calls. It is patched separately, and a fix on the canvas does not reach it.

The panel above shows the hash for the browser you are reading this in. The self-test lives in the app and runs inside a profile, against the engine that profile launched.

Four of its lines are about the canvas, and they are named in the block below. Each reports its own number rather than a verdict.

Run it in two profiles on one computer. Two hashes that differ is the reading worth having, and one run shows both.