bongsmoke.cloud
Threat model

What this protects.
And what it does not.

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>

Skip to what it does not protect you from

What the service can and cannot see

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

HalfWhere it livesWho has it
Client share256 random bits, inside the link fragmentWhoever holds the link
Server shareHMAC-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'.

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.

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.

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.

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.

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.

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.