A security page that only lists strengths is marketing. The second half of this one is everything this service cannot do for you, including the parts that are inconvenient to admit.
Messages stored
0
No endpoint accepts one. No column could hold one.
Key shares stored
0
The server’s half is computed on demand from a secret and the note ID.
Cookies
0
No Set-Cookie header, no document.cookie writes. Not “only essential ones.”
Other origins near a note
0
Nothing loads from anywhere else on /burn or /n/. Elsewhere, one: our own visit counter. No third-party scripts, fonts or ad trackers anywhere. CSP says so.
Stored per note: nothing until it is opened. After that, one burn marker: a hashed ID, a 1-byte value, no content.SET b:<hash> 1 NX EX <ttl>
Your message is encrypted in your browser with AES-256-GCM. The ciphertext travels in the URL fragment, the part after #, which browsers do not transmit. It is not in the request line, not in the Referer header, and not in any server log, ours or anyone else’s along the way.
So the server never receives the plaintext. It also never receives the ciphertext. There is no endpoint that accepts one and no column that could hold one.
This is not a policy we are promising to keep; it is a shape the system does not have.
What the server can do is compute one of the two halves of the key, on demand, from a secret and the note’s ID. It stores neither the half nor the ID, and it hands the half out once.
The split
Half
Where it lives
Who has it
Client share
256 random bits, inside the link fragment
Whoever holds the link
Server share
HMAC-SHA256(secret, noteId)
Recomputed on demand; released once
HKDF-SHA256 over their concatenation produces the AES-256-GCM key, salted with the note identifier. An optional passphrase contributes a third share via PBKDF2-SHA256 at 600,000 iterations over a random 128-bit salt carried in the fragment.
The note identifier is bound in as GCM additional authenticated data. A ciphertext lifted out of one link and pasted under a different identifier will not decrypt: it fails the authentication tag rather than producing garbage.
Why the expiry can sit in the identifier in the clear
A note identifier is 128 random bits plus its expiry. The expiry is readable by anyone. It is also an input to the HMAC, which means editing it produces a different identifier, therefore a different server share, therefore a key that decrypts nothing. Tampering is self-defeating. The server independently refuses any identifier whose expiry is in the past or further out than the longest lifetime it offers.
One-time release
Reveal performs a single atomic SET <hash> 1 NX EX <ttl>. The first caller creates the marker and receives the share; every subsequent caller, including ones arriving in the same millisecond in different regions, is told the note is gone. There is no read-then-write window.
If storage is unreachable, reveal returns a 503 and no share. A note that cannot be marked burned is not opened. The failure mode is “temporarily unavailable”, never “quietly readable twice”.
What is stored
Burn markers
One byte of value under a key derived from a keyed hash of the note identifier, not the identifier itself. Expires when the note would have expired anyway.
Rate-limit counters
An integer per endpoint per ten-minute window, keyed by a hash of the caller’s IP address rather than the address itself. Also expires on its own.
Nothing else
No user table, no message table, no ciphertext, no key share, and no log of what was created. Creating a note writes nothing about the note; the only write is the rate-limit counter above.
What is counted
We count visits with our own privacy-friendly analytics. It sets no cookies and stores nothing on your device; your IP address is used only to make a daily anonymous count and is never stored. To opt out on this site, open any page with ?ov_ignore=1.
The counter lives at overlook.technology. It is told the page’s address, with the query cut down to utm_*, ref and source and the fragment dropped, plus the referrer, whether the device has a touchscreen, how long the page was in use and how far it was scrolled, and Web Vitals. From the request it works out country, region and city, and browser, OS and device. It is not told which links you follow out.
It never loads on /burn or /n/, the two pages that ever hold a secret. No note identifier and no fragment reaches it, and those pages keep connect-src 'self'.
The important half
What this does not protect you from
Eight things, stated first and argued after. If you read one section of this page, make it this one.
The link is the credential. There is no second factor unless you add a passphrase.
If the link passes through a channel someone else can read (a shared inbox, a logged corporate proxy performing TLS interception, a group chat, a screen behind you), that person can open the note. Your recipient will then find it already burned, which is the only signal you get that it happened.
Corollary: a burned note that the recipient never opened is evidence of interception. It is worth treating as such.
02
The link persists in places you do not control
The fragment is part of a URL, and URLs are sticky.
It is in the sender’s browser history and address-bar autocomplete.
It is in whatever app was used to send it, including that app’s backups, its cloud sync, and its server-side message store.
It may be in the recipient’s history until the page clears it, which happens only after a successful reveal.
We clear the fragment from the address bar once a note is decrypted, but that only touches the current tab. It cannot reach into the sender’s history or the messaging app that carried the link.
03
A reader can keep the note
Burning destroys the key, not the reader’s memory, their screenshot, their clipboard, or the text file they pasted it into.
“Self-destructing” describes the service, not the recipient. If you would not want it written down, a note that deletes itself does not change that.
04
Whoever controls this site could serve different code
All the cryptography runs in JavaScript this site serves. You are trusting the deployment.
Anyone able to modify what is served (a compromised deployment, a stolen hosting credential, a malicious commit) could serve a version that exfiltrates the fragment before decrypting it. This is the fundamental limitation of browser-delivered cryptography and no amount of client-side design fixes it.
What is done about it: no third-party scripts, no ad trackers, no fonts or assets from other origins. /burn and /n/, the two pages that ever hold a secret, load nothing from any other origin, and their Content-Security-Policy says connect-src 'self', which leaves an injected script nowhere to send anything. The rest of the site also loads our own visit counter from overlook.technology, so there you are trusting that deployment too; nothing on those pages holds a note. What is not: there is no code-signing or reproducible-build story.
05
Metadata is not hidden
The hosting platform records HTTP requests, as every host does. That includes the note ID in the path.
We do not log request bodies or note identifiers, but the existence and timing of a note being opened is observable to someone with access to those logs, along with the address that opened it and the identifier in the request path.
That is a privacy leak, not a confidentiality one: the identifier alone cannot decrypt anything, because the client share never appears in any request. But someone with log access could open a note before its recipient, which would burn it. The threshold for that is “already has access to our infrastructure logs”.
Ciphertext is padded to size buckets, so the length of a link reveals only which bucket a message fell into, not its size.
06
The passphrase is PBKDF2, not Argon2id
Argon2id is the better choice against GPU-accelerated cracking, and we are not using it.
The honest reason is dependency and policy cost: the audited implementations are WebAssembly, which would require 'wasm-unsafe-eval' in the script policy and add a binary to the trusted bundle of an app whose entire pitch is that it is small.
PBKDF2-SHA256 at 600,000 iterations is OWASP’s current floor. It is also not the only thing standing between an attacker and the plaintext: they would need the link’s client share and the one-time server share as well. Choose a passphrase accordingly. It is a third factor, not a password protecting a database dump.
07
The deep end runs WebAssembly, on its own path
/neptune is a Godot export: a 39 MB WebAssembly engine, exactly the kind of binary the card above refuses to put next to the notes. So it is not next to them.
It has its own policy, scoped to /neptune, and the nonce middleware skips it. That policy adds 'wasm-unsafe-eval' so the engine can compile, and carries no nonce because the files are static. It keeps frame-ancestors 'none', and the only other origin it allows is the visit counter’s, as everywhere but the note pages. The engine starts with no persistent paths, so it leaves no IndexedDB database behind.
It cannot reach a note: note material only ever exists in the fragment of a /n/ page, in whichever tab holds it. The one thing same-origin script there could read is localStorage, which holds two keys at most: whether you are on the couch, and whether you opted out of the visit count.
08
Not covered at all
Some threats are out of scope for a web page, and pretending otherwise would be worse.
Traffic analysis, or a global adversary correlating timing.
A compromised endpoint on either side. Malware on the reader’s machine sees what the reader sees.
Denial of service beyond per-IP rate limiting.
Anyone who obtained the link and is willing to burn the note to read it.
Reporting something
Report it at the contact in /.well-known/security.txt. If you want it to burn, put a burn-note link in the advisory. We will read it before it does. If you believe it is a working exploit, describe the class of problem rather than publishing a recipe.
Eight limits. RFC 4:20 lists nine, and says this page wins.
You now know exactly what a note can and cannot do. Send one anyway, or read the specification it was built from.