Skip to content

Zero-knowledge, explained with code you can read

2026-11-11 · 4 min read · zero-knowledge, encryption, open-source, password-manager, security

VaultKeepR cover: Zero-knowledge, explained with code you can read

Zero-knowledge means the provider mathematically cannot read your vault, not that they promise not to read it. The proof is not a whitepaper: it is the encryption code itself. VaultKeepR's cryptographic core is MIT-licensed and public at github.com/VaultKeepR/vaultkeepr-public, so every claim in this post points to lines you can open and read yourself. This article walks through that code: how your key is derived, how the vault is encrypted, where the session key lives, and the commitment that detects vault substitution.

For a broader overview of the architecture, read what zero-knowledge encryption is on our site.

What zero-knowledge means, mathematically

A provider is zero-knowledge when the decryption key never exists outside your devices. Concretely:

  1. Your master password never leaves your device.
  2. A key derivation function turns it into an encryption key, locally.
  3. The vault is encrypted locally; only ciphertext is uploaded.
  4. The server stores ciphertext it has no way to decrypt.

The consequence is not a policy, it is arithmetic. If the server never receives the key, and the cipher is secure, then the server holds bytes indistinguishable from random noise. No employee, subpoena or breach changes that. This is the standard we hold ourselves to on the password manager page.

The opposite pattern is a provider who can reset your password by email. If they can reset it, they hold key material or a backdoor, and their "we cannot read your data" claim collapses.

The key: Argon2id with fixed parameters

The first step in the public core is deriving the key from your master password with Argon2id, configured with explicit parameters:

Argon2id(time = 3, memory = 64 MiB, parallelism = 4)
  • 64 MiB of memory per attempt makes large-scale GPU brute-force expensive, because GPUs have fast cores but comparatively little memory per core.
  • 3 iterations keep unlocking fast enough on a phone while still costing an attacker real time per guess.
  • These parameters are constants in the public code, not marketing numbers on a page.

Argon2id is the winner of the Password Hashing Competition (2015). If it were ever swapped for something weaker, it would show in the diff.

The cipher: XChaCha20-Poly1305

Vault encryption uses XChaCha20-Poly1305: a stream cipher for confidentiality, a MAC for integrity, and a 192-bit nonce so random nonces never collide in practice.

ciphertext = XChaCha20Poly1305(key, nonce, plaintext)

Two properties matter:

  • Confidentiality: without the key, the ciphertext reveals nothing about your logins, notes or documents.
  • Integrity: any modification of the ciphertext, by anyone in the chain, fails to verify at decryption. Poly1305 is not "best practice" marketing, it is the same MAC used in SSH, WireGuard and TLS.

Again, the algorithm choice lives in the public core. You do not have to trust the sentence "we use XChaCha20", you can read where the cipher is invoked.

Where the session key lives: SessionKeyStore

Deriving the key from Argon2id costs 64 MiB of memory and some time. Doing that on every read would drain your battery, so after unlock the key is held in a SessionKeyStore for the duration of the session:

  • The key stays in memory, not written to disk.
  • It is scoped to the session and cleared on lock.
  • Nothing in the store ever travels over the network.

This is a deliberate trade-off: usability requires a resident key, security requires it to be short-lived and local. The implementation is in the public repo.

The commitment: HMAC-SHA256 against vault substitution

Encryption protects against reading. A second problem is substitution: a malicious storage layer replacing your vault with an older or modified version. VaultKeepR binds the current vault with a commitment: an HMAC-SHA256 over the vault, computed with key material derived from your master password.

commitment = HMAC-SHA256(commitment_key, vault_bytes)

When your device fetches the vault, it recomputes the commitment and compares. If the stored bytes do not match the commitment, the substitution is detected before anything is decrypted. A storage node, even a fully malicious one, cannot forge a valid commitment without your key.

What zero-knowledge forbids: no email reset

VaultKeepR has no email and no account. That is not a growth hack, it is a corollary:

  • No email means no email-based account takeover.
  • No server-side key means no "forgot password" flow, because there is nothing to reset.
  • Support cannot "restore access", because support does not have your key either.

Most password managers offer email reset. That convenience requires the provider to hold something that can regenerate your access, which is exactly the property zero-knowledge excludes. We chose the math over the convenience.

What it does not prevent: key loss, and Shamir 3-of-5

Honesty requires the other column. If zero-knowledge holds, then losing your key means losing the vault. No support ticket, no recovery email, no exception.

To keep that survivable, VaultKeepR splits the recovery key with Shamir Secret Sharing:

  • Your recovery key is split into 5 fragments.
  • Any 3 fragments reconstruct it (3-of-5).
  • No single fragment, and no single holder, reveals anything on its own.

You choose where fragments live: with people you trust, on devices, in a safe. The threshold is what turns "irreversible loss" into "loss requires losing 3 separate places".

That is the complete picture: a cipher and a KDF you can read, a session key store you can read, a commitment you can read, and limitations stated as plainly as the strengths. Read the code at github.com/VaultKeepR/vaultkeepr-public, then judge the claims yourself.

FAQ

What does zero-knowledge mean for a password manager?
It means the provider cannot read your data, not that they promise not to. Your vault is encrypted on your device with a key derived from your master password, and only ciphertext reaches storage. Without your key, the provider sees random bytes.

Direct link to this question

Where can I read VaultKeepR's encryption code?
The cryptographic core is MIT-licensed and public at github.com/VaultKeepR/vaultkeepr-public. It covers key derivation (Argon2id), encryption (XChaCha20-Poly1305), the session key store and the HMAC-SHA256 commitment.

Direct link to this question

Why can't VaultKeepR reset my master password?
Because nobody at VaultKeepR ever holds your key. The key is derived locally from your master password and never transmitted. A reset by email would require the server to store key material, which would end zero-knowledge.

Direct link to this question

What happens if I lose my master password?
Zero-knowledge means no email reset and no support recovery. VaultKeepR mitigates this with Shamir Secret Sharing: your recovery key is split into 5 fragments and 3 are enough to recover access.

Direct link to this question

Is zero-knowledge the same as end-to-end encryption?
They overlap but are not identical. End-to-end encryption protects data in transit between two endpoints. Zero-knowledge additionally means the service itself has no key material, so it cannot decrypt what it stores.

Direct link to this question

Does zero-knowledge protect against everything?
No. It protects against the provider reading or modifying your vault. It does not protect against a compromised device, a weak master password, or you losing your key. We state these limits openly.

Direct link to this question

Keep reading