What Makes a Password Manager Worth Trusting: A Technical Breakdown

Password managers ask users to do something that seems counterintuitive from a security standpoint: put all their passwords in one place and trust a single piece of software with access to every account they own. Understanding whether a specific password manager is worth that trust requires knowing what the system is actually protecting against, how the cryptographic architecture handles the worst-case scenario—a breach of the manager’s servers—and what the company’s security track record says about their operational practices.

The LastPass breach of 2022 provided an unusually detailed case study for evaluating these questions. The company’s architecture and response revealed both what good password manager design looks like and where specific implementations had failed. It’s worth using as a reference point for what to look for in any password manager.

The Core Security Model: Zero-Knowledge Architecture

A trustworthy password manager should be designed so that even a complete breach of the company’s servers doesn’t give an attacker your plaintext passwords. This is the zero-knowledge architecture: the company’s servers store only encrypted data, and the keys to decrypt it exist only on the user’s devices, derived from the master password that never leaves the user’s control.

The implementation works like this: your master password is never transmitted to the password manager’s servers. Instead, it’s run through a key derivation function (KDF) on your device—modern implementations use PBKDF2, bcrypt, or the more modern Argon2—to produce a cryptographic key. That key is used to encrypt your vault before it’s uploaded to the server. The server receives only ciphertext; it has no way to decrypt your vault without the key, which it never has.

The strength of this model depends critically on several implementation details:

The key derivation function and its parameters. KDFs are deliberately slow to make brute-forcing the master password expensive. The number of “iterations” or “work factor” in the KDF determines how many computations an attacker must perform to test each password guess. More iterations mean slower cracking. LastPass’s breached vaults used 100,100 iterations of PBKDF2—a number that was already below the recommendation at the time of the breach (OWASP recommended 600,000+), and some users had even lower iteration counts from older accounts that hadn’t been migrated to current settings.

The encryption algorithm and mode. AES-256 in CBC mode was standard for many years; AES-256 in GCM mode is now preferred because GCM provides authenticated encryption (it detects tampering). Password managers that still use CBC mode are technically secure but are using a mode that doesn’t provide integrity verification.

What metadata is encrypted. Some password managers encrypt the URL fields alongside passwords; others leave URLs as plaintext in the vault. Plaintext URLs reveal which services you have accounts with, even if the credentials themselves are encrypted. In the LastPass breach, URLs were stored as plaintext, revealing what accounts affected users had even before any vault cracking was attempted.

The Breach Scenario: What Protection Looks Like in Practice

When a password manager’s servers are breached and encrypted vaults are exfiltrated, the attacker’s task is to crack the master passwords for the vaults they’ve obtained. The time and effort required depends on the master password strength and the KDF iteration count.

For a genuinely strong master password—twelve characters mixing lowercase, uppercase, digits, and symbols, not a dictionary word or pattern—the cracking time with current hardware against a high iteration count KDF is measured in millions of years. This is what “zero-knowledge” security means in practice: the encryption is strong enough that a breached vault is computationally useless to an attacker.

The risk is users with weak master passwords. A master password of “password1!” will be cracked within seconds by an attacker who has obtained the encrypted vault, regardless of how good the encryption algorithm is. The KDF slows guessing, but it can’t compensate for a password that exists in breach dictionaries.

The secondary risk is phishing attacks targeting the master password directly—not cracking the vault, but getting the user to type their master password into a fake login page. No encryption architecture protects against a compromised user device or a successful phishing attack. This is where additional factors come in: TOTP-based two-factor authentication, hardware security keys, or biometric authentication add a layer that phishing attacks alone can’t bypass.

Local vs Cloud Storage

Password managers come in two fundamental architectures: cloud-synced vaults and locally-stored vaults. Cloud-synced managers (1Password, Bitwarden, LastPass, Dashlane) store encrypted vaults on company servers and sync across devices. Locally-stored managers (KeePass and its derivatives) keep the vault file on devices you control, with no server-side storage.

Local storage eliminates the server breach attack surface entirely—there’s nothing for an attacker to exfiltrate from a company server if the vault never lives there. The trade-off is that the user is entirely responsible for backup and sync. A vault stored only on a hard drive that fails, or a phone that’s lost, takes the passwords with it unless the user has independent backup practices.

Bitwarden offers an interesting middle ground: it’s open-source and can be self-hosted. Users who want cloud sync but don’t want to trust a commercial provider’s servers can run their own Bitwarden server. This combines the sync convenience of cloud storage with control over the server environment.

Open Source and Audits: What They Tell You

Open-source password managers allow independent security researchers to review the implementation directly. This is a meaningful security advantage: it makes it possible to verify that the claimed cryptographic architecture matches the actual implementation, and it enables the community to identify implementation vulnerabilities that might not be found in internal review.

Bitwarden is fully open-source and has undergone multiple independent security audits with published results. 1Password isn’t fully open-source but has white papers documenting its cryptographic design in detail and has undergone third-party audits. LastPass’s code was proprietary, which meant the implementation details that contributed to the breach severity—iteration counts, URL storage—weren’t externally visible before the breach.

Security audits by reputable firms provide a point-in-time assessment that the implementation matches the documented design and that no critical vulnerabilities were found during the audit scope. They’re valuable but not comprehensive: audits review what the auditor can examine in the time allocated, and may miss issues outside scope.

What to Look For and What to Avoid

The characteristics of a trustworthy password manager, based on the above:

Zero-knowledge architecture with strong documentation of the cryptographic design. The company should be able to explain, in technical detail, exactly what is and isn’t stored on their servers and in what form. Vague claims of “military-grade encryption” without specifics about algorithm, mode, key derivation, and iteration counts should be a warning sign.

High-iteration KDF with user-controlled or automatically updated parameters. Modern recommendations are 600,000+ iterations of PBKDF2-HMAC-SHA256, or equivalent Argon2 parameters. A manager that hasn’t updated its default iteration counts in years is falling behind security practice.

Encryption of all vault fields, including URLs and website titles. Leaving any fields as plaintext reduces the security of the vault at rest.

Multi-factor authentication support, particularly hardware security keys (FIDO2/WebAuthn). SMS-based 2FA is better than nothing but susceptible to SIM-swapping; app-based TOTP is good; hardware keys are best.

A published breach response history that demonstrates good practices: rapid disclosure, clear communication about what was and wasn’t affected, appropriate remediation steps, and post-incident improvements to prevent similar issues. How a company responds to its worst day tells you more about its security culture than its marketing does.

The alternative to using a password manager—reusing passwords across sites, using simple memorable passwords, writing passwords in plaintext—is provably worse security. A well-designed, well-operated password manager with a strong master password and multi-factor authentication is among the most effective single security improvements most people can make. The key is understanding what “well-designed” actually means at a technical level rather than accepting marketing claims at face value.