Can a talk leak data?
A talk shows real software to a room, and anything private on a screen or in a shipped file is a leak. Ours is built to make one unlikely, not impossible: a made-up company to show, a sealed build that is the only way the talk leaves the machine it is made on, and a leak scan that fails the build. This page shows how the scan works, runs its own tests, and runs it again, fresh, over the sealed build.
What it is.
The lab in plain words, and how it runs.
A talk shows real software to a room, and anything private on a screen or in a file it ships is a leak. The question: does our leak scan catch what it should, and is the build of the talk clean?
The talk shows a made-up company, and it leaves the machine it is made on only as one sealed build. A scan checks every file in that build: of its 1,062 files, it reads the 830 text files in full and only the names of the other 232. It fails the build when it finds something private: one of the 105 terms on its list that fail the build, or the shape of a key, a path or an address. The list holds 115 terms, kept only as hashes; the other 10 are common words, which fail it only when written as a repository's address and otherwise give a warning.
We ran the scan's own tests, which plant leaks on purpose and check that each one is caught, and ran the build's check again over the sealed build. It makes a leak unlikely, not impossible: a scan only finds what its list and its shapes know.
- The sealed build1,062 files: 830 read as text, 232 by name only
- The deny-list115 terms under 8 labels, kept only as hashes
The scan's own tests
- 16 planted leakswritten by us, each to be caught with its kind
- 6 other checksthe made-up company and the build pass, the deny-list holds no plain text
- 22 passed, 0 failed
A fresh scan of the sealed build
- Each file checkedby sha256, against the build's own manifest
- Each file scanned830 as text, 232 as binary
- 0 problems, 0 errors24 warnings from the list's warn-only terms, and 470 allowed by the gate's one rule for code, explained below; neither fails the build
What is staged, and what is real.
The company on stage is made up. The scan is not.
Staged
- The company on stage. Northwind Labs, a logistics-software firm we made up: a route planner, a parcel tracking site, a fleet gateway. Its agents and people are invented, and its repositories sit under an organisation that is not ours.
- Its work. Synthetic records, made by a generator and checked to be its output, so none is typed by hand and none is copied from a real company.
- Who the talk is for. A real client, who is never named here. The talk is made for them, never as them.
Real
- The scan. The scanner as it is at the private main, cited by sha256, not a copy rewritten for this page.
- Its tests. Run on , on a Mac: 22 passed.
- The fresh scan. The build gate's own check, run on over the sealed build's zip.
How the scan reads.
The scan reads every text file it is given, twice: as written, and with its JSON escapes undone, because a name hidden inside an escaped string was missed at first. It reads every file's name too. A binary file is counted and only its name is read; the pictures in the build are drawn by our own code from the made-up company, which is itself scanned.
It fails on a private repository's name, a real person, a team machine, the client's name, a game studio's terms, a real internal figure near its name, a money amount (with one allowance, below), the shapes of tokens and keys, an e-mail address, a machine path and an internal address. A few common words that are also repository names only warn, unless they stand in a slug.
The names it protects are kept as a deny-list of 115 terms under 8 labels (105 that fail the build, 10 that warn), each stored only as the sha256 of a salt and the term, cut to 24 hex, so the list does not spell them. The real figures and the client's words come from two files that are never committed.
SUMMARY ONLY, NOT REPRODUCIBLE HERE
Hashed is not secret
A short name can be found again from its hash by trying names. What the hashing prevents is the list itself becoming the leak, through a search or a copied file. That is why this page gives the list's counts and nothing else: not its terms, not its labels, which say what each term protects, and not its figures.
Its own tests, run.
On , on a Mac, the scanner's own test ran with pytest, in a fresh copy of the private repository at its main, Python 3.12.13: 22 passed, 0 failed. 16 of them each plant one leak and check it is caught, with its kind; the other 6 check that the made-up company and the build are clean, that a leak in a built bundle fails the command, that a file's name is read, that the deny-list holds no plain text, and that the presenter and the fiction pass.
AN AUTHORED FIXTURE, WRITTEN BY US
The planted leaks are ours. The real names among them are read from our own files when the test runs, and the client's name is stored encoded, so the test itself carries no private plain text. The 16 kinds:
- the client's name
- an e-mail address
- a game studio's terms
- an internal address
- a machine path
- a team machine's name
- a real internal figure
- a money amount
- a figure beside its name
- the GitHub organisation's name
- a real person
- a private repository's name
- a GitHub token
- a signed web token
- an invite link's token
- an API key
A fresh scan of the sealed build.
On , on a Mac, with the build gate's own verify step at that main, run over the sealed build's zip. The zip, eac018ab4b9235e08cb347cb77b7e91ce435c698845ae3285618a300b69e24df, was first checked against its parts manifest: its 152,739,288 bytes, and its 4 parts, each by sha256 and joined back into the zip. Then the gate checked each of the build's 1,062 files against the build's own manifest by sha256, and scanned every one of them: 830 as text, 232 as binary.
0 problems, 0 errors. 24 warnings, and 470 allowed.
- A warning is one of the common words that are also repository names, outside a slug. It does not fail the build.
- An allowed finding is the gate's one allowance: a dollar sign and one to three digits in a JavaScript file, such as a pattern's back-reference or a name a bundler made up. The gate takes every such match in a JavaScript file as code, and does not check each one, so a real amount of that shape in a JavaScript string would pass it too. A plain scan without that one rule reads each as a money amount, and fails.
The findings' text is not published, only these counts. The commit the build was made from is not on the private main, so this page names the build by its zip's sha256 instead, and does not cite it.
Check it yourself.
Everything on this page comes from one record, published here and pinned by its sha256. It was read from the leak scan of the agent space's private repository: the scanner, its test and planted leaks, the hashed deny-list and the talk-safety note, read at its main. Private commit aa35e6db, cited by hash, checked as part of the private main aa35e6db on ; this page cannot check it, anyone with access can.
Before it was published, this page, its record, its tile and its template were run through the same scan; what it found is published too, file by file by sha256, with this site's own public names set aside and counted. The build refuses to publish if any of those files has changed since.
The commits it stands on
- The sealed build made the one way the talk leaves its machine, with a scan over every shipped file, and the talk-safety note, . Private commit
c090fccf, cited by hash, checked as part of the private mainaa35e6dbon ; this page cannot check it, anyone with access can. - The planted leaks and the scanner's test, sixteen of them caught with their kind, . Private commit
9464a47c, cited by hash, checked as part of the private mainaa35e6dbon ; this page cannot check it, anyone with access can. - The deny-list kept as salted hashes, so the list does not spell the names, . Private commit
53a861e5, cited by hash, checked as part of the private mainaa35e6dbon ; this page cannot check it, anyone with access can. - The leak scan as it stands at main, . Private commit
968dde25, cited by hash, checked as part of the private mainaa35e6dbon ; this page cannot check it, anyone with access can. - The build gate as it stands at main, . Private commit
18607b66, cited by hash, checked as part of the private mainaa35e6dbon ; this page cannot check it, anyone with access can.
The files, by sha256
- The leak scan:
e4d8c9f5229c75e211e80c966c6b95a1d2e408d3f5c475252edb0e0023eb5c27 - The build gate, which makes the sealed build and verifies it:
d74616dfa60b0e94e8664c099ac29ec39086cd1142bd6d0a41592e83b899cda9 - The leak scan's test:
d5ec4b0f3d93d8973b57d5e295b03afa1c6d2b01249648fa22d7b1e4bb4ea2a4 - The planted leaks the test is run with:
2d673e6c90ee48ede6dae9af27299aa7de95d0d2606670300f28a8b1794e0716 - The hashed deny-list:
bd92d70c6679ae3ab5b08b4849763b23bd97813f291d64933a872485642af649 - The talk-safety note:
16120236ade91335291543de5bc2d94d910d3c9be703837c3cfb407ac0808902
Main was checked by GitHub compare of each cited commit against the private main head; behind by 0 means the commit is part of main, on .
What this does not show.
- A scan only finds what its list and its shapes know. A name missing from the list is caught only by a person reading.
- The hashes hide the list from a search, not from someone trying names.
- A binary file's contents are not read, only its name; and a dollar sign with one to three digits in a JavaScript file passes the gate unchecked.
- The sealed build itself is not published, so its zip's hash cannot be checked here. Anyone with the build can.
- The build is meant to reach nothing beyond the machine it runs on. This page did not test that: it scanned the build's files, it did not watch it run.