Search as you type
The list narrows as you type. Search reads the notes and password fields too, so an entry you only half remember still surfaces — but the list itself shows only the title, username, and URL.
Open source · self-hosted · no accounts
A password manager
you actually own.
One master password unlocks your logins. They are encrypted in your browser and only ever leave it as ciphertext, so the server that syncs them between your devices cannot read a single one.
Try the demo Get it on GitHub How it works
Install it as an app on your phone or desktop. Works fully offline. Chrome extension included.
- Encrypted in the browserWebCrypto, AES-GCM, Argon2id
- No accountsNo email, no username, no sign-up
- Works offlineAdd and search with no network
- One Go binaryNo CGo, no node_modules
What it does
The parts you use daily, and the parts you hope never to need.
Copy without leaving a trail
One tap copies a username, password, or URL. A copied password is wiped from the clipboard automatically after about 20 seconds, and you choose the delay.
Two-factor codes built in
Store a site's authenticator key with its entry and the record shows the live six-digit code with a countdown. One less app to open — read the trade-off in the design notes before you use it.
Sync that cannot read you
Devices sync through your own Go server. Edits on different entries merge silently; when the same entry changed in two places, the app shows you both versions and lets you choose.
Emergency recovery sheet
Mark an entry critical and it goes on a printed sheet — straight to the printer, never a PDF. Paper survives a dead phone, a wiped laptop, and ransomware.
Chrome extension
Unlock, search, copy, read a 2FA code, and fill the form on the page you are looking at. It reuses the same vault code as the app, so there is one implementation of the crypto, not two.
A look at it
Real screens, filled with invented logins.
Open the demo to use the real app on a public server, including syncing one vault between two devices. Demo vaults hold 100 entries, and every one is deleted seven days after it is created, so keep real passwords out of them.
How the encryption works
Three sentences, because you should be able to check the claim rather than trust it.
-
A vault key encrypts every entry
One random AES-GCM key, generated in your browser, encrypts each entry as its own record. Each ciphertext is bound to its entry's id, so a hostile server cannot swap one entry's secret onto another.
-
Your password wraps that key
The master password goes through Argon2id — 64 MiB of memory per guess, which is what takes the advantage away from a GPU farm — and the result encrypts the vault key and nothing else.
-
Unlocking is decrypting
Entering the password tries to unwrap the vault key. A wrong password simply fails to decrypt. No password hash is stored anywhere, on your device or on the server.
What the server can and cannot see
It can see
- How many entries a vault holds
- When each one last changed
- An opaque random Vault ID
It cannot see
- Any title, username, password, URL, or note
- Your master password, or any hash of it
- The name you gave the vault
That is why several unrelated people can share one small server without trusting each other. Each vault is its own namespace, and writing to a vault requires a credential derived from its key — which only unlocking can produce.
There is no recovery
Nobody holds a spare key, because nobody can. Lose the master password and the data is gone for good. Print the emergency recovery sheet, keep an encrypted export somewhere safe, and treat that password as the one thing you must not forget.
Run it yourself
One binary serves the app and stores the ciphertext in SQLite. Run it on your laptop, on a small VM, or on someone else's server — it cannot read your vault either way.
git clone https://github.com/hammondus/ownvault.git
cd ownvault
go build -o ownvault .
./ownvault # http://localhost:8080
./ownvault -token "$(openssl rand -hex 16)" # public deploymentPut it behind a reverse proxy for TLS. The README covers the flags, the Docker deployment, and the phone install steps; DESIGN-DECISIONS.md explains why each part is built the way it is.
Take a look at the code
It is one Go file, a handful of vanilla JavaScript modules, and no build step. Read all of it in an evening.