Hush

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.

The Hush create page after upload: the share link, the delete link, and a panel listing what the server received: a secret id, 568 bytes of ciphertext in one chunk, a 36-byte public header, and not the link key.
After upload, the sender sees exactly what the server received. Screenshot of the real app in headless Edge.

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.

How a secret travels

  1. 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.
  2. Upload. POST /api/secrets sends the 36-byte header and the encrypted metadata and returns an id and a deletion token. Each chunk follows with PUT, then POST .../seal. The server checks lengths against the header; it has no key to check anything else.
  3. Share. The link is /s/{id}#{key}. Chat apps and preview bots that fetch it get a static page; nothing is consumed by a GET.
  4. Open. The recipient's page reads the key from location.hash, checks a password against the encrypted metadata first, then sends POST .../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.
  5. 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.
The Hush view page before reveal: contains text, 73 bytes, expiry time, 1 view left, and a Reveal secret button with a warning that this is the last view.
The recipient's page before Reveal. Loading it spends nothing.

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/...#...'