Zero-knowledge secret sharing. The server never sees a thing.
Hush encrypts a text or a file on your device with AES-256-GCM, uploads only ciphertext, and puts the key after the # in the link, the part of a URL that browsers never send to a server. The server enforces expiry and view limits on bytes it cannot read, and deletes them after the last view.
This page is static. Hush itself is a PHP 8.3 server you run yourself (Docker image included); there is no public instance behind this site. The demo below runs the real envelope code in your browser and talks to nothing.
Seal something, in this page
These are the same core/ modules the Hush pages load: format.js encodes the envelope, crypto.js calls WebCrypto. Nothing is uploaded.
The link
The id comes from the server; the part after # is the 256-bit key, generated here.
The public header, byte by byte
The only plaintext the server stores. It is also the associated data of every encrypted record, so changing any byte breaks them all.
| Bytes | Field | Value |
|---|
Sizes
Text and metadata are padded to 256-byte blocks before encryption, so a 4-digit PIN and a 200-character API key produce the same ciphertext length.
Round trip
Tamper with it
What a malicious server could try. AES-GCM authenticates every record together with the header, its kind and its index.
How a secret travels
- Seal. The sender's browser (or
bin/hush) draws a random 32-byte key, derives the content key with HKDF-SHA256 (mixing in PBKDF2 of the password when there is one), pads the data to 256-byte blocks and encrypts the metadata and each 512 KiB chunk with AES-256-GCM. - Upload.
POST /api/secretssends the 36-byte header and the encrypted metadata and returns an id and a deletion token. Each chunk follows withPUT, thenPOST .../seal. The server checks lengths against the header; it has no key to check anything else. - Share. The link is
/s/{id}#{key}. Chat apps and preview bots that fetch it get a static page; nothing is consumed by aGET. - Open. The recipient's page reads the key from
location.hash, checks a password against the encrypted metadata first, then sendsPOST .../open. One SQL statement claims the view and marks the last one burned, so two readers racing for a one-view secret cannot both win. - Burn. After the last view the rows are deleted once the response has been sent; a garbage-collection command removes expired, abandoned and interrupted ones.
What the server can still see
Ciphertext length rounded to 256 bytes, chunk size and count, whether a password was used, expiry and view counts, and the IP address and time of each request while it is being handled. Hush does not store addresses: rate-limit buckets are keyed by an HMAC of the client network, and the Docker image writes no access log.
The hard limit is the one every browser-based end-to-end tool has: the page's JavaScript comes from the server it is meant to distrust. An operator who changes crypto.js could read secrets sent through the browser. The terminal client does not have this problem, because it encrypts with code already on your machine. The threat model covers this and the other limits.
Run it
git clone https://github.com/TIENDUNG21/hush-zero-knowledge-vault cd hush-zero-knowledge-vault docker compose up -d --build # http://127.0.0.1:8080 # or without Docker (PHP 8.3 with pdo_sqlite and openssl) composer install php bin/hush-admin migrate php -S 127.0.0.1:8080 public/index.php # from a terminal, against either echo 'staging DB password: example-only' | php bin/hush send --server http://127.0.0.1:8080 --views 1 php bin/hush get 'http://127.0.0.1:8080/s/...#...'