Client-side encryption, explained without jargon
"Encrypted" is printed on almost every app and website, yet the word covers very different things. A service can encrypt your data and still be able to read it whenever it wants. Client-side encryption, often called end-to-end encryption, is the version where the service genuinely can't. This guide explains the difference in plain words, shows what our server actually receives, and how you can check it yourself in a few minutes, without taking our word for it.
Three kinds of "encrypted"
The question that matters is not "is it encrypted?" but "who holds the key?"
- Encryption in transit (HTTPS): the padlock in your browser. It protects data between your device and the server from anyone on the same Wi-Fi or along the network. On arrival, the server decrypts it and sees everything. Essential, but silent about what happens next.
- Encryption at rest: the server stores data encrypted on its disks, so a stolen drive or a misplaced backup is unreadable. But the service holds the key, because it must read the data to serve it. An employee with access, an attacker inside the running system or a legal request can still reach readable content.
- Client-side (end-to-end) encryption: data is encrypted on your device before it leaves, with a key the server never receives. The server stores and relays scrambled bytes it cannot read. Only you, and whoever you give the key to, can turn them back into text.
An analogy: HTTPS is the armored truck between your house and the bank; encryption at rest is the bank's vault, whose combination the bank knows. Client-side encryption is a box you lock at home: the bank keeps the box but never gets the key.
Where the key lives: the URL fragment
A ShareSafeNote link ends with something like #k=Q2xhaXJl…. Everything after the # is called the fragment. It was designed to jump to a section of a page, which is why browsers handle it entirely on your side: when your browser requests a page, it sends the address up to the # and keeps the fragment to itself. The fragment is not part of the HTTP request, so it never shows up in the server's logs.
ShareSafeNote relies on that property. When you create a note, your browser generates a random 256-bit key, encrypts the note, sends only the encrypted result to the server, and puts the key in the fragment of the link it gives you. When the recipient opens the link, the page's JavaScript reads the key from the fragment, downloads the ciphertext and decrypts it locally. The direct consequence: the link is the key. Whoever has the full link can read the note; whoever has only the server's data cannot.
AES-GCM in plain words
The encryption uses AES-256-GCM through the Web Crypto API built into modern browsers: no homemade cryptography. Two ideas matter:
- Confidentiality: AES with a 256-bit key turns your text into data that looks random. Without the key, there is no practical way back: guessing a 256-bit key is beyond the reach of any computer that exists.
- Tamper detection: GCM adds an authentication tag, a kind of seal. If anyone changes even one bit of the ciphertext, decryption fails instead of producing altered text. You get the original note or an error, never a silently modified version.
Each note also gets a random 12-byte IV (initialization vector). It is not secret: it ensures encryption never repeats itself identically, and it is stored next to the ciphertext.
What the server actually sees
Here is roughly what a stored note amounts to (values invented and shortened):
id: r4Tq9ZkP2mWciv: 9xR2vLq0ZbN1sW8ect: Hk7mQ2pZ0fXc4Lw1tR8yNvB3…created: 14:02 · expires: 15:02 · one-time: yes · reads: 0
That's it: no title, no sender, no recipient, no key. The id finds the record; the IV and ciphertext are useless without the key in the fragment. Because there are no accounts, no email addresses, no analytics and no tracking cookies, the server also has very little to tie a note to a person; IP addresses are only used briefly, in memory, for rate limiting. The server runs on Render in the United States; what it stores is ciphertext plus a few timestamps and counters, never the keys.
The same principle applies to live code sessions: the relay only passes ciphertext along, in memory only, never on disk.
Check it yourself in DevTools
- On a computer, open the create page, then the developer tools (F12, or Ctrl+Shift+I; Cmd+Option+I on a Mac) and select the Network tab.
- Type a recognizable test note, such as "purple elephant 42", and create it.
- Click the request that appears and inspect what it sent (the Payload or Request tab, depending on the browser). You should see an encoded blob, not your words, and no key.
- Scan the request addresses: none of them contains the
#k=part of your link. - Open the link in a private window with the Network tab open. Nothing loads the note until you click the decrypt button; then only ciphertext arrives, and decryption happens in the page.
What you still have to trust
Client-side encryption removes the need to trust the server's storage, but not everything:
- The JavaScript itself. The code that encrypts your note is delivered by the site on every visit. A compromised site could serve code that leaks the key. Your DevTools check shows what the code does today, not tomorrow. Self-hosted libraries remove third-party CDNs from the chain, not the site itself.
- Browser extensions. An extension allowed to "read and change data on all websites" can read the page, the decrypted note and the key in the address bar. Prune your extensions and use a browser profile without extensions for sensitive notes.
- The devices at both ends: malware, a shared computer, screen recording.
- The link's journey: browser history (which keeps the fragment), synced clipboards, forwarded messages, screenshots.
To see it in action, create a test note with the Network tab open and follow the steps above. Going further: sharing API keys safely. Spotted something odd? Write to support@sharesafenote.com.