Every knowledge check, in one place

Before the math: what cryptography is actually trying to do, and the 2,500-year arms race between codemakers and codebreakers that got us here.

Every public-key algorithm in this catalog leans on the same idea: a calculation that's easy in one direction and effectively impossible to undo in the other.

The same key locks and unlocks the data. Fast, simple in concept, and everywhere — from disk encryption to the bulk of every TLS session.

AES's predecessor and the first cipher the world ever standardized. What retired it wasn't a flaw in the design — it was a key that was always too short.

Not every symmetric cipher works in fixed blocks. ChaCha20 generates a keystream instead — and paired with Poly1305, it's AES-GCM's fastest rival.

Four ways to prove a message came from someone holding a shared key and wasn't changed on the way: one built from a hash, one from a block cipher, two from polynomial arithmetic.

A block cipher encrypts 16 bytes. Everything else (long messages, randomness, tamper detection, even keeping a card number a card number) comes from the mode wrapped around it, and that's where most real-world breaks happen.

Two mathematically linked keys — one public, one private — solve the problem symmetric crypto can't: how do you share a secret with someone you've never met?

Textbook RSA is deterministic and malleable. Padding schemes are what actually make RSA encryption and signing safe to use in the real world.

The same public-key guarantees as RSA, with dramatically smaller keys — because the underlying hard problem is different math entirely.

Two parties agree on a shared secret over a public channel, without ever transmitting the secret itself — the idea that started public-key cryptography.

Diffie-Hellman lets two people agree on a secret together. ElGamal uses that same discrete-log idea to let anyone encrypt to a public key — no live handshake required.

One-way fingerprints for data, and the mechanism that proves a message is authentic and untampered — without encrypting anything.

A cryptographic hash is too fast for passwords. KDFs deliberately slow things down — and not all of them do it the same way.

A certificate is just a signed statement binding a public key to an identity. Here's what's actually inside one, and how revocation works.

JWTs put a signed claim in every request header. They're everywhere in modern APIs — and a few well-known implementation mistakes keep recurring.

A passkey is what you get when you replace a password with a public-key challenge-response protocol. It fixes reuse, phishing, and breaches in one move.

The protocol behind every remote login and git push combines the same primitives as TLS, arranged slightly differently.

Every padlock icon runs a coordinated handshake combining key exchange, certificates, symmetric encryption, and integrity checks — in under a round trip.

TLS protects data in transit to a server. The Signal Protocol's Double Ratchet goes further — encrypting so not even the server operator can read your messages.

128-bit AES, 2048-bit RSA, 256-bit ECC — these numbers aren't comparable at face value. Here's how to actually read them.

Every key, nonce, and IV in this catalog assumes truly unpredictable randomness. When that assumption breaks, everything built on top breaks with it.

Randomness can't just be assumed good or bad — it's measured. This module covers min-entropy, the real NIST test suite for entropy sources, and why a hardware random number generator still needs that testing.

A cryptographic algorithm can be mathematically unbreakable and still leak its secret key through how long it takes to run.

Bitcoin and Ethereum don't invent new cryptography — they compose the same primitives in this catalog into a specific, tamper-evident structure.

How do you protect a master key so no single person holds it, yet any k of a trusted group can reconstruct it together? Split it across a polynomial.

The bridge module: why everything above is called "classical" cryptography, and exactly what a future quantum computer would do to it.

You don't need a working quantum computer today to be at risk today. Anything encrypted now with RSA or ECC can simply be recorded and decrypted later.

Every cloud KMS — AWS KMS, GCP Cloud KMS, Azure Key Vault, HashiCorp Vault — uses the same pattern to encrypt data without ever moving your master key. Here's why, and how it actually works.

Envelope encryption covers wrapping a key with your own KMS. This is about the broader problem: getting a key from one system, person, or organization to another — without it ever existing in the clear outside a trust boundary.

Wrapping and unwrapping keys, covered so far, all happens somewhere. PKCS#11 is the standard interface that lets an application talk to that somewhere — an HSM, a smart card, a USB token — without caring which vendor built it.

The X.509 module covers what's inside one certificate and how a chain verifies. This is the other half: how an organization actually runs the CA hierarchy that issues, automates, and eventually retires millions of them.

"Just use OAuth" conflates three different standards solving three different problems. Here's what each one actually does, how they relate to the JWTs you already know, and where passkeys fit in.

Before a PIN can be translated or a CVV checked, someone has to get the first key into the HSM. How custodians, XOR'd components and key check values do that under dual control, and how one master key then protects every other key in a payment system.

How a card PIN is packaged, encrypted at the point of entry, and re-encrypted hop by hop across acquirer, network, and issuer — without ever existing in the clear outside a hardware security module.

How the card verification value printed on the back of a card is generated, why the magstripe and card-not-present versions deliberately don't match, and why PCI DSS treats storing it as an absolute rule, not a guideline.

How a chip card and an issuer's host cryptographically prove to each other that they're both genuine, transaction by transaction — using a key that exists nowhere outside that one card and a cryptogram that's never reused.

Card-not-present purchases can't rely on a physical chip proving anything — so 3-D Secure authenticates the cardholder instead, and tokenization makes sure the real card number is never the thing worth stealing in the first place.

Encrypting a card number with AES-GCM breaks every schema and system that expects 16 digits. Format-preserving encryption turns it into another 16 digits instead. Here's how vaultless tokenization works, where it fits next to a token vault, and what it quietly gives up.

How millions of PIN pads each encrypt every transaction under a different key, while the acquirer's HSM holds just one Base Derivation Key, and why the industry is moving from TDES DUKPT to AES DUKPT.

Every operating system update, driver, mobile app, and container image you install is checked against a digital signature first. Here's what that signature actually binds, why timestamps and revocation dates matter more than the algorithm, and why signing keys now have to live in hardware.

Malware that runs before the operating system can hide from everything that runs after it. Secure boot makes each boot stage verify the next, starting from a key the attacker can't change. Here's how UEFI Secure Boot, measured boot, and anti-rollback fit together, and where they have failed.

Every major cloud encrypts your data by default. The real question is who controls the key: the provider, you inside the provider's KMS, a key you generated and imported, or a key that never leaves your own HSM. Here's what each option protects against, and what it costs.

Almost every algorithm in this catalog traces back to a NIST publication. Here's what NIST actually is, how it picks a winner, and the full list of what it's standardized.

TLS, JWT, PKIX certificates, SSH — every protocol module on this site cites an RFC. Here's how the IETF actually produces them, and what "RFC" does and doesn't guarantee.

A federation of national standards bodies, not a single organization — and the source of both ISO/IEC 27001 certification and the international equivalent of NIST's own algorithm standards.

SAML, PKCS#11, and KMIP all live here — a member-driven consortium, not a government body, that ended up stewarding some of the most load-bearing identity and key-management specs in production today.

Neither a government agency nor an open consortium: EMVCo is owned outright by the card networks, and PCI SSC enforces compliance rather than publishing algorithms. Here's how chip, PIN, CVV, and 3DS specs actually get made — and why some of the math behind them is deliberately never published at all.

FIPS 197 tells you what AES is. FIPS 140-3 tells you what a library, token, or HSM implementing it has to do before a lab will sign off on it: a defined boundary, self-tests, key handling, and physical protection graded from Level 1 to Level 4.

Where FIPS 140-3 tests every module against one fixed list, Common Criteria lets the vendor (or a protection profile) state the security claims, then grades how rigorously a lab checked them. Here's how to read 'EAL4+', and why it says less than it seems to.

FIPS 140-3 and Common Criteria certify products. eIDAS is EU law: it decides when an electronic signature counts as much as a handwritten one, who may issue the certificates behind it, and where the key has to live. ETSI's EN 319 series supplies the technical detail. Here's how the pieces fit, from QES and QSCDs to AdES formats and the new EUDI Wallet.