Project: Encrypted Message Vault

Build vault.py, a CLI secrets vault:

• init — create a new vault locked by a passphrase.
• add <name> / get <name> / list / remove <name> — manage secret entries.
• Everything encrypted at rest with a key derived from the passphrase (Lesson 14).
• Integrity: a wrong passphrase or tampered file is rejected, never silently misread.

vault.dat layout:
  [ 16-byte salt ][ Fernet token of the encrypted JSON of all secrets ]

Flow:
  passphrase + salt ──KDF──► key ──► Fernet ──► encrypt/decrypt the JSON blob
  - salt stored in the file (not secret)
  - key derived in memory each run (NEVER written to disk)
  - wrong passphrase → InvalidToken → "wrong passphrase", refuse

Key derivation & load/save

import base64, os, json, getpass
from pathlib import Path
from cryptography.fernet import Fernet, InvalidToken
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes

VAULT = Path("vault.dat")
ITERATIONS = 480_000               # slow KDF — resists brute force

def _derive_key(passphrase: str, salt: bytes) -> bytes:
    kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32,
                     salt=salt, iterations=ITERATIONS)
    return base64.urlsafe_b64encode(kdf.derive(passphrase.encode()))

def _load(passphrase: str) -> dict:
    """Decrypt the vault into a dict of secrets, or raise on wrong passphrase."""
    blob = VAULT.read_bytes()
    salt, token = blob[:16], blob[16:]
    key = _derive_key(passphrase, salt)
    try:
        plaintext = Fernet(key).decrypt(token)        # authenticated → tamper-safe
    except InvalidToken:
        raise ValueError("wrong passphrase or corrupted vault")
    return json.loads(plaintext)

def _save(secrets: dict, passphrase: str, salt: bytes) -> None:
    key = _derive_key(passphrase, salt)
    token = Fernet(key).encrypt(json.dumps(secrets).encode())
    VAULT.write_bytes(salt + token)               # salt + ciphertext

The salt is generated once at init and stored in the file header; every load/save re-derives the key from the passphrase + that salt. Fernet's authentication means a wrong passphrase (wrong key) or a tampered file raises InvalidToken — we turn that into a clear "wrong passphrase" error rather than ever returning garbage.

Wire the crypto core into commands, prompting for the passphrase securely (no echo) with getpass.

import argparse, os, getpass

def _ask() -> str:
    return getpass.getpass("Passphrase: ")        # not echoed to the terminal

def _salt_of() -> bytes:
    return VAULT.read_bytes()[:16]

def cmd_init(a):
    if VAULT.exists():
        print("vault already exists"); return
    pw = _ask()
    if pw != getpass.getpass("Confirm: "):
        print("passphrases don't match"); return
    salt = os.urandom(16)
    _save({}, pw, salt)
    print("vault created 🔒")

def cmd_add(a):
    pw = _ask()
    try:
        secrets = _load(pw)
    except ValueError as e:
        print(e); return
    secrets[a.name] = getpass.getpass(f"Secret for '{a.name}': ")
    _save(secrets, pw, _salt_of())
    print(f"stored '{a.name}'")

def cmd_get(a):
    pw = _ask()
    try:
        secrets = _load(pw)
    except ValueError as e:
        print(e); return
    print(secrets.get(a.name, f"no entry named '{a.name}'"))

def cmd_list(a):
    pw = _ask()
    try:
        secrets = _load(pw)
    except ValueError as e:
        print(e); return
    print("\n".join(secrets) if secrets else "(empty vault)")

def cmd_remove(a):
    pw = _ask()
    try:
        secrets = _load(pw)
    except ValueError as e:
        print(e); return
    if secrets.pop(a.name, None) is not None:
        _save(secrets, pw, _salt_of()); print(f"removed '{a.name}'")
    else:
        print("no such entry")

if __name__ == "__main__":
    p = argparse.ArgumentParser(description="Encrypted secrets vault.")
    sub = p.add_subparsers(dest="cmd", required=True)
    sub.add_parser("init").set_defaults(func=cmd_init)
    for name, fn in [("add", cmd_add), ("get", cmd_get), ("remove", cmd_remove)]:
        sp = sub.add_parser(name); sp.add_argument("name"); sp.set_defaults(func=fn)
    sub.add_parser("list").set_defaults(func=cmd_list)
    args = p.parse_args(); args.func(args)

$ python vault.py init
Passphrase: ········
Confirm: ········
vault created 🔒

$ python vault.py add github-token
Passphrase: ········
Secret for 'github-token': ········
stored 'github-token'

$ python vault.py get github-token
Passphrase: ········
ghp_xxxxxxxxxxxxxxxx

$ python vault.py get github-token
Passphrase: ········   (wrong)
wrong passphrase or corrupted vault

Read the result

The vault file on disk is pure ciphertext — open it in a text editor and you see random bytes, not your secrets. The passphrase is typed via getpass (never echoed, never stored), the key is derived fresh in memory each run via a slow KDF, and Fernet's authentication guarantees a wrong passphrase or any tampering is rejected cleanly. Every crypto concept from this arc is here: hashing/KDF (11-12), symmetric authenticated encryption (14), and the "protect the key" discipline (14, 16). It's a genuinely useful tool you could keep using.

The vault composes the crypto arc into a real password manager: a passphrase + stored salt feed a slow KDF (11-12) to produce a key, used by Fernet (14) to encrypt the secrets blob at rest — with the key living only in memory, never on disk. Fernet's authentication means a wrong passphrase or any tampering is cleanly rejected (no silent corruption). getpass keeps the passphrase off the screen. Lose the passphrase, lose the data — that's the security guarantee, the same zero-knowledge design real managers use. Hardening (iteration headers, rotation, clipboard clearing) turns it production-grade.