Your code does come to us

Stated first, because everything else on this page depends on it being true. A scan clones your repository onto infrastructure we pay for. No arrangement described below changes that, and any page that opens with the reassuring part is hiding this one.

What changes is who can look at it once it is there. The answer, for a private repository, is nobody — including us.

It is read on a machine we cannot log into

A private repository is cloned inside a Confidential VM: one container, named by cryptographic digest, running on memory the host cannot read. The image has no shell and no SSH. We cannot get into it either — not with our own cloud credentials, not by attaching a debugger, not by asking an engineer nicely. If we could, the guarantee would be ours to break, and it would be worth what our word is worth.

The machine is built for your scan and destroyed after it. Google signs a statement naming which image ran and on what hardware, and that statement is attached to your report.

The credential is the part that matters

Anyone can promise not to read your code. The reason to believe this one is that the access token which clones your repository is released only to that image.

It reaches the machine as ciphertext, encrypted under a key our own servers may encrypt with and cannot decrypt. Decryption is granted to a workload whose attestation Google has checked — right image, production boot image, genuine confidential hardware. Our web tier cannot obtain it. Our worker cannot obtain it. A person with full access to our cloud console cannot obtain it. There is no path, rather than a policy.

You do not have to take our word for any of it

Your report carries the raw signed token. Fetch /r/<owner>/<repo>/<commit>/attestation.json, check the signature against Google's public keys, and compare the image digest to the one we publish at /.well-known/borehole-workload. The token also carries a hash of your report, so it proves that image produced your scan and not merely that it ran somewhere.

The full verification steps, and what this still does not prove The honest limits are on that page, not buried.

What it costs you

About a minute. Building a machine and pulling an image takes longer than starting a container, so a private scan is slower than a public one. That is the price of the guarantee and we would rather charge it than quietly skip it: if the confidential machine cannot be built, the scan fails. It never falls back to ordinary infrastructure, because a report that silently came from the tier you were avoiding would look exactly like one that did not.

Public repositories stay on ordinary infrastructure

Deliberately. The code is already readable by anyone, so a hardware-isolated machine buys a reader nothing they do not already have, and paying a minute of boot time for it would make the product worse rather than safer. The lesser tier is a considered choice, not a shortfall.

The short version, either way

• The access token is scoped to reading contents, minted for one scan, and discarded after it.
• The working copy is deleted when the scan ends, including when it fails.
• No source content reaches any language model.
• The report that survives contains pointers — commit, path, line range — not your source. Three checks quote a line, and you can remove those with one click.
• Every report carries a record of what its own scan did, written by the steps as they ran.

The record on your report

Every report carries a table like this, produced by the code that performed each step rather than written alongside it:

A hand-written description of a data flow goes stale the first time somebody changes the flow and not the description. This cannot, because the flow writes it. If a step did not run it is absent; if the scan died partway, what got as far as happening is still there.

What we structurally cannot do

These are not promises. They are consequences of how the thing is built, and each one is asserted by a test that fails the build.

• The web tier cannot clone. There is no git binary in its image. Continuous integration checks this on every build.
• The worker cannot mint its own access. It holds no long-lived GitHub credential. A token is created by the web tier for one job, and burned after it.
• The worker runs as nobody. Non-root, read-only filesystem, every Linux capability dropped.
• The working copy is deleted in a finally. It goes when the scan raises, not only when it succeeds.
• Reports hold no contributor identities. Authorship is counted, never named — a report contains no email addresses.

What you control

• Who can read it. A private report is readable by the account that paid, by anyone GitHub says controls the repository, and by nobody else. It is never listed, never generates a shareable card, and never generates a badge.
• Whether anyone else can. You can mint a share link for a counterparty with no GitHub account. Anyone holding it can read the report — the page says so — and you can revoke it or replace it.
• The quoted lines. Three checks quote text because in each case the text is the evidence: a TODO's wording, a commit subject, an unpinned dependency. One click removes them from the stored report. The pointers stay, so you can still find the line yourself.

What we still cannot prove

If that is not enough

For some codebases it should not be, and we would rather say so than win the argument. If your code cannot leave your infrastructure under any circumstances, a hosted scan is the wrong tool and no amount of this page changes that. Tell us what you need — we would rather route you somewhere honest than sell you something that does not fit.

See also the Privacy Policy, which lists every processor and what each one holds, and the Terms.