Your files never leave your device. All processing happens locally in your browser.
How do I store my passwords securely in my browser for free without an account?
Open the Password Vault, choose a master passphrase, and add your logins — each one holds a title, username, password, URL, notes and tags. The whole vault is sealed with authenticated AES-256-GCM using a key stretched from your passphrase with PBKDF2-HMAC-SHA-256, and only the ciphertext is stored in this browser’s IndexedDB. Unlock decrypts it into memory; Lock wipes it. A built-in generator fills strong passwords, copied secrets auto-clear the clipboard after ~15 seconds, and you can export the encrypted vault as a backup. Everything is 100% client-side — nothing is uploaded, and a forgotten passphrase is unrecoverable.
One master passphrase encrypts the entire vault as a single AES-256-GCM blob
PBKDF2-HMAC-SHA-256 (210,000 iterations) stretches the passphrase over a fresh random salt
Only ciphertext is saved to IndexedDB — never plaintext, never the passphrase
CSPRNG password generator (crypto.getRandomValues), clipboard auto-clear, and idle auto-lock
100% client-side — nothing is uploaded; a lost passphrase means the vault is unrecoverable
What is
Client-side password vault (AES-256-GCM + PBKDF2)
A password vault is an encrypted store for login credentials unlocked by a single master secret. This tool runs entirely in the browser: every entry (title, username, password, URL, notes, tags) is serialised to JSON and encrypted as one blob with AES-256-GCM — an authenticated cipher that both hides the data and detects tampering — using a 256-bit key derived from the master passphrase with PBKDF2-HMAC-SHA-256 over a fresh random salt. Only the resulting ciphertext is persisted to IndexedDB via idb-keyval; the passphrase and decrypted entries live only in memory while the vault is unlocked. It is a convenient private, local vault, not a synced or independently audited password manager.
No. The vault is encrypted and stored only in this browser and never leaves your device.
Everything runs 100% client-side using the browser’s native Web Crypto API. Your entries are encrypted into a single AES-256-GCM blob and written only to this browser’s IndexedDB — there is no upload, no account, no server, no CDN in the crypto path and no telemetry. The master passphrase and the decrypted entries exist only in the tab’s memory while the vault is unlocked and are cleared when you lock it or close the tab. Because nothing is synced, the vault lives on exactly one device until you export it, so export a backup regularly. The only optional network use anywhere on the site is consent-gated ads, which never see your vault.
The entire vault is permanently unrecoverable — there is no reset, escrow or backdoor.
The encryption key is derived from your master passphrase alone and is never stored, so there is no way to recover the vault without it — no recovery email, no master key, no support override. If the passphrase is lost, the stored ciphertext is effectively random data forever. This is deliberate: it is what makes the vault private. Choose a long, unique passphrase (the create screen includes a strength meter and can suggest a strong random one) and write it down somewhere safe. A wrong passphrase simply fails the AES-GCM authentication and cannot decrypt anything.
AES-256-GCM with a PBKDF2-HMAC-SHA-256 key, and passwords come from crypto.getRandomValues.
The vault is sealed with authenticated AES-256-GCM. The 256-bit key is derived from your passphrase with PBKDF2-HMAC-SHA-256 using 210,000 iterations and a fresh 16-byte random salt, with a random 12-byte IV per encryption — all via the Web Crypto API. GCM produces a 128-bit tag, so any tampering or a wrong passphrase is detected rather than returning garbage. The built-in generator draws every character from window.crypto.getRandomValues with unbiased rejection sampling (never Math.random), lets you set length and character classes and avoid ambiguous characters, and shows the ideal entropy in bits. OWASP’s 2025 guidance suggests higher PBKDF2 counts (310k–600k) for server-side hashing; the practical ceiling here is still your passphrase strength.
No — it is a private local vault, not a synced, audited, breach-monitoring manager.
The cryptography is real and standard, but the threat model is narrower. The vault is not synced across devices, has no autofill, no breach monitoring and no independent security audit, and it lives only in this browser — clearing site data, private mode or a browser reinstall can wipe it. On a shared or malware-infected device your passwords can be read while the vault is unlocked, and any cross-site-scripting flaw in the page could read the decrypted vault in memory. It is ideal for a private, offline, local store you fully control, but for cross-device sync, breach alerts and audited security use a dedicated manager such as Bitwarden, password manager apps or KeePass.
Detailed Explanation
📖How It Works
What the Password Vault Does
The Password Vault is a 100% client-side password manager. The user creates a vault protected by one master passphrase, then adds login entries — each holds a title/site, username or email, password, URL, notes and tags. Entries can be added, edited, deleted, searched and filtered by tag; every change re-encrypts the whole vault. Unlocking decrypts the vault into memory; Lock wipes the decrypted entries and the passphrase from memory. A built-in generator fills strong passwords, secrets can be revealed or copied (with the clipboard auto-clearing after ~15 seconds), and the encrypted vault can be exported to a file for backup. Nothing is uploaded, there is no account, and the vault lives only in this browser.
One master passphrase unlocks a vault of login entries
Fields: title, username/email, password, URL, notes and tags
Add, edit, delete, search and tag-filter — every change re-encrypts
Lock wipes decrypted entries and the passphrase from memory
Everything runs in the browser — the vault is never uploaded
⚙️Methodology
How the Encryption Works
A pure engine (passwordVaultEngine.ts) serialises the entire vault to JSON and encrypts it as a single blob by reusing a shared client-side crypto core (textCryptoEngine.ts). The master passphrase is stretched into a 256-bit key with PBKDF2-HMAC-SHA-256 using 210,000 iterations and a fresh 16-byte random salt, then the JSON is sealed with authenticated AES-256-GCM under a random 12-byte IV; the salt, IV and iteration count are packed into a self-describing header so the blob decrypts with nothing but the passphrase. Only that ciphertext is persisted, to this browser’s IndexedDB via idb-keyval — never the plaintext and never the passphrase. On unlock the blob is read and decrypted into memory; on every add, edit or delete the vault is re-encrypted with a fresh IV and rewritten. Export wraps the same ciphertext in a small JSON envelope; import restores it and requires the original passphrase to unlock.
Whole vault encrypted as one AES-256-GCM blob (authenticated)
PBKDF2-HMAC-SHA-256, 210,000 iterations, fresh 16-byte random salt
Random 12-byte IV per encryption; header carries salt, IV and iteration count
Only ciphertext is stored in IndexedDB — never plaintext or the passphrase
Every change re-encrypts with a new IV before rewriting the blob
🔧Technical Details
Authenticated Encryption and Secure Randomness
AES-GCM is an AEAD cipher: alongside the ciphertext it produces a 128-bit tag that is verified on decryption, so a wrong passphrase or any tampering with the stored blob fails cleanly instead of returning garbage — the UI reports “wrong passphrase, or the vault was altered”. All security-relevant randomness comes from window.crypto.getRandomValues, never Math.random: the salt, the IV and every entry id. The built-in password generator also draws from getRandomValues using unbiased rejection sampling (rejecting values above the largest multiple of the pool size so there is no modulo bias), guarantees at least one character from each selected class, and shuffles the result with a CSPRNG Fisher–Yates pass; it exposes length, character classes and an avoid-ambiguous option and reports the ideal entropy in bits (length × log2 of the pool). Copied passwords are cleared from the clipboard after ~15 seconds to limit exposure.
AES-256-GCM verifies a 128-bit authentication tag on decryption
Salt, IV and entry ids all come from crypto.getRandomValues
Generator uses unbiased rejection sampling — no modulo bias, never Math.random
Entropy shown in bits: length × log2(character-pool size)
Copied secrets auto-clear from the clipboard after ~15 seconds
⚠️Limitations
Honest Limitations
The cryptography is standard and strong, but the threat model is deliberately narrow. The vault lives only in this browser — it is not synced or backed up anywhere, so it exists on one device until the user exports it, and clearing site data, private mode or a browser reinstall can wipe it. A forgotten master passphrase makes the entire vault permanently unrecoverable: there is no reset, no escrow and no backdoor, because the key is derived from the passphrase alone and never stored. Security is capped by passphrase strength — a short or reused one can be brute-forced offline if someone obtains the ciphertext. On a shared or malware-infected device the passwords can be read while the vault is unlocked, and any cross-site-scripting flaw in the page could read the decrypted vault in memory; JavaScript also cannot guarantee decrypted secrets are fully purged from RAM. There is no autofill, no breach monitoring and no cross-device sync. This is a private, local vault, not an independently audited password manager — for those needs, use Bitwarden, password manager apps or KeePass.
Not synced or backed up — the vault lives on one device until exported
A lost master passphrase makes the whole vault permanently unrecoverable
Security is capped by passphrase strength; clearing site data can wipe the vault
A shared/compromised device or XSS can expose the vault while it is unlocked
No autofill, breach monitoring or sync — not a substitute for an audited manager
🔒Privacy & Security
Private by Design
Everything happens on the user’s device. Key derivation and AES-256-GCM run locally via the browser’s native Web Crypto API; the vault is encrypted before it touches storage, and only the ciphertext is written to IndexedDB — there is no network request, no upload, no logging, no account, no server and no CDN anywhere in the crypto path. The master passphrase and the decrypted entries exist only in the tab’s memory while the vault is unlocked and are cleared on lock, on idle auto-lock, or when the tab closes. Generated passwords never leave the page, exported backups stay encrypted, the tool works offline once cached, supports dark mode and a mobile-first responsive layout, and has no analytics or telemetry. The only optional network use anywhere on the site is consent-gated ads, which never see the vault. This matters because the entire point of a vault is privacy — so the secrets must never round-trip through a server.
Encryption/decryption run locally via the Web Crypto API
Only ciphertext is stored in IndexedDB — no upload, server or CDN
Passphrase and decrypted entries live only in memory — cleared on lock/close
Works offline once cached; dark-mode and mobile-first
Only optional network use is consent-gated ads that never see the vault
Design choices and why they were made
Component
This tool
Weaker common choice
Why it matters
Cipher
AES-256-GCM (authenticated)
AES-CBC or plaintext localStorage
GCM detects tampering; a wrong passphrase fails cleanly
Key derivation
PBKDF2-HMAC-SHA-256, 210k iters
A single hash or none
Iteration count slows offline passphrase guessing
Salt / IV
Fresh random per encryption
Fixed or reused IV
A reused GCM nonce breaks confidentiality entirely
Randomness
crypto.getRandomValues, unbiased
Math.random
CSPRNG output is unpredictable; no modulo bias
Clipboard
Auto-clears secrets after ~15s
Left in the clipboard
Limits exposure to other apps reading the clipboard
Security ultimately depends on master-passphrase strength; a lost passphrase is unrecoverable and the vault is not synced. Everything runs locally in the browser; nothing is uploaded. As of July 2026.
