Password Managers: Why You Need One and How to Choose

In October 2022, the authentication platform Okta suffered a breach through their support ticketing system. In January 2023, LastPass disclosed that attackers had exfiltrated encrypted vault data for an undisclosed number of customers — the breach had begun months earlier when a LastPass engineer's home computer was compromised via a vulnerable Plex media server. In March 2023, it emerged that some of those vaults were being actively cracked because customers had used weak master passwords or old, low-iteration PBKDF2 settings.

These incidents do not argue against using a password manager. They argue for using one correctly — choosing a manager with sound cryptographic design, setting a strong master password, and understanding the actual threat model. Without a password manager, you are reusing passwords across hundreds of sites, and when any of those sites is breached, every account sharing that password is compromised. That is a mathematically worse outcome than any of the password manager incidents that have ever occurred.

Why Password Reuse Destroys Your Security

Credential stuffing is the most common attack that actually succeeds against consumer accounts. The mechanics:

1. An attacker acquires a breach database — these are freely available on hacking forums. The 2019 "Collection #1" aggregation contained 773 million email/password pairs. RockYou2021 contained 8.4 billion entries.
2. An automated tool tests these pairs against target services. Tools like Snipr, SNIPR, OpenBullet, and Puppeteer-based custom scripts run thousands of login attempts per minute, distributing requests across residential proxies to evade IP-rate limiting.
3. For any site where you reused a password, the attempt succeeds automatically.

The cascade failure is the real damage. Your email is the root of your digital identity — every password reset flows through it. An attacker with your email password can access your inbox, trigger resets on your bank, PayPal, AWS, GitHub, and cryptocurrency exchanges, and lock you out of every account in minutes.

In 2023, the video streaming platform 23andMe suffered a credential stuffing attack that compromised approximately 6.9 million customer profiles. The company was unambiguous: the attack exploited password reuse, not a vulnerability in 23andMe's own systems. Customers who reused credentials from other breached sites had their genetic and ancestry data exposed.

The Spotify and Netflix credential stuffing operations run continuously. Lists of working Netflix credentials are sold on Telegram channels. The attack requires no hacking skill — just automation and a large enough credential database.

The Math of Reuse

If you use the same password on 15 sites and one site's database is breached with recoverable hashes (MD5, unsalted SHA-1, or even some bcrypt implementations against weak passwords), you have effectively handed over 15 accounts. If one of those 15 is your email or password manager, you have handed over everything that flows through those accounts.

Password managers solve this with a simple mechanism: generate a cryptographically random, unique password for every site. The human never sees, types, or memorizes most of them. The password for your Amazon account looks like gK9#mP2@vL7qRn4$dX8&wJ5% — 24 random printable characters. If Amazon is breached tomorrow, the attacker has a hash of that password and nothing else. It does not work anywhere else. They cannot even brute force it — the expected cracking time against bcrypt exceeds the age of the universe.

How Password Managers Actually Work

The core concern people have is obvious: isn't putting every password in one place creating a single point of failure? The answer requires understanding the cryptographic model, not the marketing claims.

Zero-Knowledge Architecture

Reputable password managers use zero-knowledge architecture: the vendor cannot read your passwords even if compelled to do so or if their servers are breached.

The mechanism in detail:

1. Key derivation: Your master password is never stored or transmitted to the vendor. Instead, it is fed through a key derivation function (KDF) — typically PBKDF2, Argon2, or bcrypt — with a high iteration count and a user-specific salt. This process is slow by design: it might take 300ms on your device. That is imperceptible to you but catastrophic for an attacker trying billions of guesses.

2. Local encryption: The output of the KDF is an encryption key. Your entire vault is encrypted locally on your device with AES-256-GCM or ChaCha20-Poly1305 before anything leaves your device.

3. Ciphertext sync: Only the encrypted blob reaches the vendor's servers. They store gibberish from their perspective. If their entire database is stolen — as happened with LastPass in 2022 — the attacker gets encrypted vaults that are computationally infeasible to crack against a strong master password.

4. Local decryption: When you need a password, your device receives the encrypted vault, derives the encryption key from your master password (locally), decrypts the vault locally, and fills the credential. The vendor never has the plaintext.

This is not a theoretical claim — the cryptographic proofs for zero-knowledge KDF-based encryption are well-established. The attack surfaces are the master password strength, the device endpoint, and the iteration count of the KDF.

Master Password
       |
       v
  KDF (Argon2id/PBKDF2)  ← salt (stored with vault)
       |
       v
  Encryption Key (never stored, never transmitted)
       |
       v
  AES-256 Encrypt(Vault)
       |
       v
  Ciphertext → Vendor Servers (useless without master password)

The LastPass Breach Analysis

The August 2022 LastPass breach, disclosed in December 2022 and clarified through March 2023, is the most instructive real-world case. What attackers stole:

• Encrypted vault data (customer passwords)
• Unencrypted metadata: website URLs (not the passwords themselves, but which sites you have accounts on)
• PBKDF2 iteration counts used for each customer's vault

The PBKDF2 iteration count is the critical detail. LastPass's default was historically 5,000 iterations (upgraded to 100,100 by 2023, but many older accounts remained at lower settings). By contrast, Bitwarden defaults to 600,000 PBKDF2 iterations. The lower the iteration count, the faster an attacker can test master password guesses against the stolen vault.

Security researcher Wladimir Palant estimated that attackers with a stolen vault encrypted at 5,000 PBKDF2 iterations could test approximately 1.7 million master password guesses per second on a single GPU. Against 600,000 iterations, that drops to under 15,000 guesses per second. The difference determines whether a compromised vault's master password is recoverable within hours or within centuries.

If you use LastPass, verify your iteration count under Account Settings and update it to at least 600,000 if not already changed.

Comparing Your Options: 1Password vs. Bitwarden vs. KeePassXC

There is no universally correct choice. The right password manager depends on your threat model, technical comfort, and whether you accept cloud storage. Here is an honest evaluation of the three most commonly recommended options.

Bitwarden

Best for: Most people, especially those who want free, open-source, audited, and cloud-synced.

Bitwarden is fully open-source — clients, server, and cryptographic implementations are publicly visible and have been audited by Cure53 (2018, 2020, 2022). The audit reports are publicly published. The free tier is genuinely complete: unlimited passwords, cross-device sync, basic 2FA, and all core functionality. The premium tier at $10/year adds TOTP generation, advanced 2FA options (hardware keys), vault health reports, and Bitwarden Send.

Cryptographic implementation:

• Key derivation: PBKDF2-SHA256 with 600,000 iterations (default as of 2023); configurable to Argon2id in settings
• Vault encryption: AES-256-CBC with HMAC-SHA256 for integrity
• Master password never transmitted; all cryptography performed client-side
• Optional self-hosting: deploy on your own server via Docker, keeping encrypted vaults entirely under your control

# Self-hosted Bitwarden (Vaultwarden community implementation)
# Vaultwarden is a lightweight compatible server in Rust
 
docker run -d --name vaultwarden \
  -v /vw-data/:/data/ \
  -p 80:80 \
  -e DOMAIN="https://vault.yourdomain.com" \
  -e ADMIN_TOKEN="your_admin_token_here" \
  vaultwarden/server:latest
 
# Full Bitwarden server (official, heavier)
# Uses docker-compose with multiple services
curl -Lso bitwarden.sh \
  "https://func.bitwarden.com/api/dl/?app=self-host&platform=linux"
bash bitwarden.sh install

The Bitwarden CLI enables scripting and programmatic access:

# Install
npm install -g @bitwarden/cli
 
# Login
bw login user@example.com
 
# Unlock vault and get session token
export BW_SESSION=$(bw unlock --raw)
 
# Search and retrieve password
bw get password "github.com"
 
# List all items
bw list items | jq '.[].name'
 
# Generate a password
bw generate -lusn --length 24

Weaknesses: The UI is functional but not as polished as 1Password. Some minor features are premium-only. The migration path from LastPass's proprietary vault format requires some manual work.

1Password

Best for: Individuals, families, and teams willing to pay for the best UX and deepest platform integration, particularly on Apple devices.

1Password is closed-source but has published independent security audits from multiple firms, including a comprehensive review by Cure53 and ongoing SOC 2 Type 2 compliance reports. The pricing is $2.99/month for individuals, $4.99/month for families (up to 5 users), and $7.99/user/month for teams.

What makes 1Password's cryptographic model different:

The Secret Key is 1Password's distinguishing security feature. In addition to your master password, 1Password generates a 34-character, 128-bit-entropy Secret Key locally on first account creation. The encryption key is derived from both your master password and the Secret Key. Neither component alone can decrypt the vault.

Encryption Key = KDF(Master Password + Secret Key + Salt)

This means even if an attacker steals your master password (via phishing, keylogging, shoulder surfing), they cannot decrypt your vault without the Secret Key — which is never transmitted to 1Password and exists only in your Emergency Kit and on enrolled devices. A server-side breach of 1Password's infrastructure exposes encrypted vaults but not the Secret Keys needed to decrypt them.

The tradeoff: the Secret Key adds meaningful protection against server-side compromise and weak master passwords, but it also means that losing your Emergency Kit without having it stored somewhere recoverable can result in permanent account lockout if all your enrolled devices are lost.

# 1Password Emergency Kit contains:
# - Account email address
# - Secret Key (34 characters, e.g., A3-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX)
# - Space to write your master password
# Print this and store it in a safe or safety deposit box

Notable features:

• Travel Mode: Remove specified vaults from devices temporarily. When crossing a border where device searches are a risk, sensitive vaults can be hidden and restored after crossing.
• Watchtower: Monitors your credentials against HIBP breach data, flags sites with known vulnerabilities, flags sites where 2FA is available but not enabled, and flags reused or weak passwords.
• TOTP built-in: Store and generate TOTP codes for sites directly in 1Password (controversial — you're storing "something you know" and "something you have" in the same place, but operationally convenient).
• Passkey support: Store and sync passkeys across devices.
• Deep browser integration: 1Password browser extensions detect form fields precisely and handle unusual login flows that other managers fumble.

Weaknesses: Closed source (cannot verify cryptographic claims independently beyond audit reports). No self-hosting. No free tier. The iOS and macOS integration is excellent; Windows and Android are good but slightly behind.

KeePassXC

Best for: Technical users who want maximum control, offline storage, and zero vendor dependency. High-security environments, air-gapped workstations, and users who cannot tolerate third-party cloud storage under any circumstances.

KeePass stores your vault as a local encrypted file in .kdbx format. KeePassXC is the recommended modern fork (the original KeePass is Windows-only and uses .NET; KeePassXC is cross-platform C++ with better UI and active development). Sync is your responsibility — use Syncthing, a self-controlled cloud drive, or a USB drive.

Cryptographic implementation (KDBX 4 format):

# KeePassXC uses:
# - Argon2id key derivation (KDBX 4 — strongly preferred over KDBX 3.1's AES-KDF)
# - AES-256 or ChaCha20 for vault encryption
# - Optional key file: requires possession of a specific file in addition to password
#   The key file adds ~256 bits of additional entropy

# Key file + password means:
# EncryptionKey = KDF(password + key_file_contents)
# Someone with your password but not the key file cannot decrypt the vault

The key file is a powerful addition to the threat model. You can store the key file on a separate USB drive — an attacker who steals your vault file from your encrypted laptop cannot decrypt it without both the password and the physical USB drive.

# Create a new database with Argon2id KDF via CLI
keepassxc-cli db-create --set-key-file /path/to/keyfile.key vault.kdbx
 
# Add an entry
keepassxc-cli add --username "user@example.com" vault.kdbx github.com
 
# Get a password
keepassxc-cli show vault.kdbx "github.com"
 
# Generate a password
keepassxc-cli generate --length 32 --upper --lower --numeric --special
 
# Export to CSV (for migration)
keepassxc-cli export --format csv vault.kdbx > export.csv

Mobile apps: KeePassDX on Android and Strongbox on iOS are excellent. Both support KDBX 4, Argon2, key files, and biometric unlock. Syncing the .kdbx file via Syncthing or encrypted cloud storage is straightforward once set up.

SSH agent integration: KeePassXC has built-in SSH agent support — it can store SSH private keys in the vault and expose them to the SSH agent without writing them to disk:

# Enable in: Tools → Settings → SSH Agent
# Add private key to an entry: Advanced → Attachments
# Enable "Add key to agent when database is open"

Weaknesses: No emergency access mechanism. Cross-device sync requires manual setup. No built-in breach monitoring. The initial setup is significantly more technical than cloud-based options.

Full Feature Comparison

| Feature | Bitwarden Free | Bitwarden Premium | 1Password | KeePassXC | |---|---|---|---|---| | Price | Free | $10/yr | $36/yr+ | Free | | Open Source | Yes | Yes | No | Yes | | Independent Audit | Yes (published) | Yes | Yes (published) | Yes | | Cloud Sync | Yes | Yes | Yes | Manual (your choice) | | Self-host | Yes | Yes | No | N/A (local) | | Key Derivation | PBKDF2/Argon2id | PBKDF2/Argon2id | PBKDF2 + Secret Key | Argon2id | | Emergency Access | No | Yes | Yes (Emergency Kit) | No (manual) | | Hardware Key 2FA | No | Yes (FIDO2) | Yes (FIDO2) | No | | TOTP Generator | No | Yes | Yes | Yes | | Passkey Support | Yes | Yes | Yes | No | | Breach Monitoring | Limited | Yes (HIBP) | Yes (Watchtower) | No (manual) | | Browser Extensions | All major | All major | All major | All major | | Mobile Apps | iOS, Android | iOS, Android | iOS, Android | Via KeePassDX/Strongbox | | CLI | Yes | Yes | Yes | Yes | | SSH Agent | No | No | Yes (SSH keys) | Yes | | Travel Mode | No | No | Yes | Manual | | Key File Support | No | No | No (Secret Key instead) | Yes |

The Verdict

For most people: Bitwarden free. It removes all financial friction, covers every core use case, is genuinely open-source and audited, and has no meaningful limitations that matter for personal use. Start here.

For teams and organizations: 1Password Teams or Bitwarden Organization. 1Password's team management UX is better; Bitwarden's organization pricing is significantly lower. Both support granular access controls, shared vaults, and administrative oversight.

For high-security individuals and air-gapped environments: KeePassXC with Argon2id, a key file on a separate USB drive, and Syncthing for sync.

Your Master Password Is Everything

Zero-knowledge encryption is as strong as your master password. If your master password is weak, your encrypted vault is crackable — as demonstrated by the post-LastPass-breach cracking activity reported in 2023.

Diceware Passphrases

The strongest and most memorable master passwords use diceware: randomly selected words from a large wordlist, where the randomness comes from physical dice rolls or a cryptographic random number generator.

The EFF Large Wordlist contains 7,776 words (6^5 — five dice rolls per word). Each word adds log₂(7,776) ≈ 12.9 bits of entropy. A five-word passphrase gives 64.5 bits of entropy. A six-word passphrase gives 77.4 bits.

# Generate a diceware passphrase programmatically
import secrets
 
# EFF Large Wordlist (download from https://www.eff.org/files/2016/07/18/eff_large_wordlist.txt)
def load_eff_wordlist(filepath: str) -> dict:
    words = {}
    with open(filepath) as f:
        for line in f:
            dice, word = line.strip().split('\t')
            words[dice] = word
    return words
 
def diceware_passphrase(word_count: int = 6) -> str:
    wordlist = load_eff_wordlist('eff_large_wordlist.txt')
    selected = []
    for _ in range(word_count):
        # Simulate 5 dice rolls using cryptographically secure randomness
        roll = ''.join(str(secrets.randbelow(6) + 1) for _ in range(5))
        selected.append(wordlist[roll])
    return ' '.join(selected)
 
# Example output: "correct horse battery staple pencil mirror"
# Entropy: 6 × 12.9 = 77.4 bits
# Do NOT use this exact phrase — generate your own

Never use a passphrase you have seen in an example — correct horse battery staple (from the famous XKCD comic) is now in wordlists. Generate fresh phrases with actual dice or a vetted generator.

Rules for Your Master Password

• Minimum 5 random diceware words (64+ bits of entropy)
• Unique: never used anywhere else, ever
• Never typed into anything other than your password manager's unlock field
• Never stored digitally in plaintext
• Written on paper, stored physically in a secure location (home safe, safety deposit box, sealed envelope with a trusted person)
• Memorized through active daily use — type it yourself for the first two weeks rather than relying on biometric unlock

On biometric unlock (Face ID, Touch ID, fingerprint): Biometrics are a convenience layer, not a replacement for the master password. They locally authenticate you to the device, which then retrieves the already-unlocked vault session. Know your master password. A dead phone battery or a forced device reset requires the actual password.

Migration: Getting All Your Passwords In

The single biggest obstacle to adoption is migration. Here's how to do it without being overwhelmed.

Phase 1: Import What You Have

Every major browser exports saved passwords as CSV:

Chrome / Brave / Edge:

Settings → Passwords → Three-dot menu → Export passwords

Firefox:

about:logins → Three-bar menu → Export Logins

Safari:

Preferences → Passwords → three-dot menu → Export All Passwords

All major password managers import from these CSV files. Import immediately — even a messy, duplicate-filled import gives you a starting inventory.

# Bitwarden CLI import example
bw import --format chrome /path/to/chrome_export.csv
 
# 1Password supports drag-and-drop import of CSV files from the desktop app
 
# KeePassXC: Database → Import → CSV

Phase 2: Rolling Replacement

Do not attempt to audit and fix all 200+ accounts on day one. That path leads to exhaustion and abandonment. Instead:

Every time you log into a site, update that password to a freshly generated random password. Within a normal month of web usage, you'll have replaced 80+ accounts organically — the highest-traffic ones first.

Configure your browser extension to detect password fields and prompt to update. In Bitwarden, this appears as the toolbar icon showing a number badge when it detects a site you have a credential for.

Phase 3: Immediate Priority Accounts

Do not wait for rolling replacement to reach these:

1. Primary email — everything else is recoverable through email. If email falls, everything falls.
2. Secondary email — also recoverable path target.
3. Banking and financial accounts — Venmo, PayPal, brokerage, crypto exchanges.
4. Password manager account itself — circular but important for cloud-based managers.
5. Domain registrar — if you own domains, losing the registrar account means losing email routing.
6. Cloud storage — Google Drive, iCloud, Dropbox contain documents and often 2FA backup codes.

Change all of these to generated passwords and enable TOTP 2FA (or hardware keys) on the same day you set up the password manager.

Phase 4: Clean Up Old Accounts

Your inbox contains dozens of registrations you forgot about. Search for "welcome to", "confirm your email", "verify your account", "your account has been created". Every forgotten account is a potential breach vector.

Delete accounts you no longer use. Under GDPR, EU companies must honor deletion requests. US-based services vary, but most major platforms honor them. Justdeleteme.com rates the difficulty of deleting accounts on popular services.

For accounts that cannot be deleted, change the email to an alias, change the password to a generated one, and store it in your vault under a "defunct" folder.

Emergency Access and Account Recovery Planning

A password manager that only you can access is one concussion away from a family crisis.

Bitwarden Emergency Access (Premium)

Bitwarden's emergency access feature allows you to designate trusted contacts who can request access to your vault. The flow:

1. You designate a trusted contact (they must have a Bitwarden account).
2. If you are incapacitated, they click "Request Access."
3. You receive an email notification with a waiting period you set (between 1 day and 90 days).
4. If you do not deny the request within the waiting period, they gain read or takeover access to your vault.
5. If you deny, access is blocked. The waiting period prevents unauthorized access while you're still capable.

This mechanism requires you to be alive and alert to deny it — not to grant it. That asymmetry is the security design.

1Password Emergency Kit

1Password generates a printable Emergency Kit PDF during account setup. It contains your email, your Secret Key, and a blank field for your master password. Print it. Store it.

The kit must be updated if your master password changes. Treat it like a will: update it when circumstances change, store it somewhere your family would find it, and tell someone where it is.

KeePassXC Physical Backup

KeePassXC has no built-in emergency access. The practical solution:

1. Store a copy of your .kdbx vault file in a location your family can access (USB drive in a safe, or an encrypted cloud drive with shared access credentials stored in the same safe).
2. Write your master password (and key file location, if using one) on paper.
3. Store both in a physically secure location specified in your will or estate documents.
4. Update annually or after any password change.

What to Document Regardless of Which Manager You Use

Store this information in a physically secure location (sealed envelope, fireproof safe, safety deposit box):

Password Manager Emergency Information
=======================================
Manager: [Bitwarden / 1Password / KeePassXC]
Account Email: _______________________
Master Password: _____________________
[1Password only] Secret Key: __________
Recovery Codes: [paste or attach printed codes]
Vault File Location (KeePass): _________
Key File Location (KeePass): __________

Last Updated: _______________

Review this annually. The most common failure is a stale emergency kit that references a master password that was changed three years ago.

Security Model Limitations: What Password Managers Cannot Protect

Be clear-eyed about what zero-knowledge encryption does and does not protect against.

Protected:

• Server-side breach of the password manager vendor's infrastructure
• Network interception of vault sync traffic
• Vendor employees reading your passwords
• SQL injection attacks against the vendor's database

Not protected:

• Malware running on your device at the time you type your master password. A kernel-level keylogger or a browser extension with broad permissions can capture your master password before it is processed by the KDF.
• A compromised browser extension. Malicious browser extensions that mimic password manager extensions have appeared in extension stores.
• Physical access to an unlocked, authenticated session. If your vault is open on your screen, its contents are accessible to anyone with screen access.
• Biometric bypass via court order, coercion, or certain technical vulnerabilities. In jurisdictions where biometric unlock is used, this can compel vault access even without the master password.
• Supply chain compromise of the password manager software itself. Mitigated by open source and independent auditing, but not eliminated.

Advanced Configuration

Argon2id in Bitwarden

Bitwarden allows switching from PBKDF2 to Argon2id for KDF:

Settings → Security → Keys → KDF Algorithm → Argon2id
Recommended: Memory: 64MB, Iterations: 3, Parallelism: 4

This is more resistant to GPU cracking than PBKDF2 because Argon2id requires substantial memory in addition to computation — memory is expensive to parallelize on GPUs. Set this before your vault has substantial data. Bitwarden will re-derive and re-encrypt your vault with the new parameters.

Hardware Key 2FA for Password Manager Access

The vault is only as secure as the authentication to unlock it. For Bitwarden Premium and 1Password, hardware security keys (FIDO2) are supported for the account login step. This means even if an attacker has your email and master password, they cannot authenticate to download your vault without the physical hardware key.

This does not protect the local vault cache on enrolled devices — but it does protect against remote attacks against the cloud sync mechanism.

CLI Integration for Developers

Storing API keys, service credentials, and infrastructure secrets in a password manager with CLI access is significantly better than .env files:

# Bitwarden CLI — fetch credentials in shell scripts
export BW_SESSION=$(bw unlock --raw)
 
# Get an API key by name
API_KEY=$(bw get password "AWS Production IAM")
 
# Get username and password separately
DB_USER=$(bw get username "PostgreSQL Production")
DB_PASS=$(bw get password "PostgreSQL Production")
 
# Use in scripts without embedding credentials
psql -U "$DB_USER" -h db.example.com -d mydb
 
# 1Password CLI (op)
export AWS_ACCESS_KEY=$(op item get "AWS Production" --field "Access Key ID")
export AWS_SECRET_KEY=$(op item get "AWS Production" --field "Secret Access Key")

# 1Password with GitHub Actions — using op inject
# .github/workflows/deploy.yml
steps:
  - name: Configure AWS
    uses: 1password/load-secrets-action@v1
    env:
      OP_SERVICE_ACCOUNT_TOKEN: ${{ secrets.OP_SERVICE_ACCOUNT_TOKEN }}
    with:
      export-env: true
    # In your .env.template file:
    # AWS_ACCESS_KEY_ID=op://vault/aws-prod/access_key_id
    # AWS_SECRET_ACCESS_KEY=op://vault/aws-prod/secret_access_key

Getting Started Right Now

The migration overhead is real but finite. The cost of not migrating is a credential stuffing attack that compromises your financial accounts, your email, and your digital identity simultaneously.

Decision tree:

• Technical comfort: low, budget: $0 → Bitwarden free. Install the browser extension, create an account, import your browser passwords in 15 minutes.
• Technical comfort: medium, budget: $3/month → 1Password. Better UX on Apple devices, team features if needed.
• Technical comfort: high, cloud storage unacceptable → KeePassXC with Argon2id and a key file.
• Organization of 10+ people → Bitwarden Organizations or 1Password Teams. Both support SSO integration, group-based vault access, and admin controls.

The ideal password manager is the one you actually use consistently. Do not spend two weeks evaluating options — pick one today, migrate your email and banking passwords tomorrow morning, and spend the next month rolling out the rest.

Action Checklist

• [ ] Choose and install a password manager today (Bitwarden is the zero-friction starting point)
• [ ] Create account and set a 5+ word diceware master passphrase
• [ ] Change KDF to Argon2id in settings (Bitwarden) or verify Secret Key is safely stored (1Password)
• [ ] Import browser-saved passwords
• [ ] Immediately change passwords for email, banking, password manager account itself
• [ ] Enable hardware key or TOTP 2FA on the password manager account
• [ ] Install browser extension and enable autofill
• [ ] Install mobile app
• [ ] Write emergency access information on paper and store it securely
• [ ] Over the next 30 days: change passwords on every site you log into
• [ ] After 30 days: use vault's health report to find reused and weak passwords, fix remaining issues
• [ ] Annual: verify emergency kit is current, audit account access, review and delete old accounts