Glossary

150 terms from Cryptography and PKI, in plain words, each with the chapter that teaches it.

Search the glossary

#

0-RTT early data: Data a returning client sends in TLS 1.3 before the handshake has finished. Because it arrives before fresh keys are agreed, it can be replayed, so servers accept it only for safe requests.
3DES (Triple DES): An older symmetric cipher that runs DES three times. It is now retired, and AES replaces it.

A

AES (Advanced Encryption Standard): The standard symmetric block cipher, used almost everywhere, including HTTPS, VPNs, disk encryption and Alex's backups. It encrypts data in 128-bit blocks with 128-, 192- or 256-bit keys, and AES-256 in GCM mode is a common strong default.
AESGCM: The class in Python's `cryptography` library that does AES encryption in GCM mode, giving both secrecy and an integrity tag in one step. Its `encrypt` and `decrypt` methods take a nonce, the data and optional additional data.
Algorithm (cipher): The fixed, published recipe that turns plaintext into ciphertext with a key, and back again. Everyone can know how it works, because only the key is secret.
Argon2id: The modern first-choice function for hashing passwords. It is deliberately slow and uses a lot of memory, which defeats attackers who guess in parallel on graphics cards.
Asymmetric encryption: Encryption where each person has a linked pair of keys, one public and one private, and what one key locks only the other can open. It solves the key-sharing problem but is slow, so it is mainly used to set up keys and to make signatures.
Authenticated encryption: Encryption that also guarantees integrity, using a tag so any change to the ciphertext makes decryption fail instead of returning corrupt data. AES-GCM is the standard example.
Authentication tag: A 16-byte value that GCM adds to the ciphertext. Decryption checks it, so even one flipped bit is detected.
Avalanche effect: A tiny change to a hash's input, such as one letter of "Kettle and Crane", gives a completely different output. That is why there is no such thing as a "close" hash.

B

base64: A common encoding that rewrites bytes as letters so binary data can travel in places like email. It uses no key and anyone can reverse it with base64 -d, so it gives no secrecy.
bcrypt: A well-trusted password-hashing function that salts automatically and has an adjustable work factor. A stored value like $2b$10$... holds the version, the cost, the salt and the hash together.
BitLocker: Microsoft's full disk encryption for Windows. Alex uses it on the laptop that connects to the order server.
Block cipher: A cipher that encrypts data in fixed-size blocks. AES works on 128-bit (16-byte) blocks, and a mode of operation joins the blocks into a whole message.
Brute force: Trying every possible key until one works. Long keys make it hopeless: a 128-bit AES key would take about the age of the universe to find.

C

CBC (Cipher Block Chaining): An older block cipher mode that mixes each block with the one before it, so patterns in the data disappear. It is common in older systems but gives no built-in integrity like GCM does.
Certificate: A small signed file that binds a public key to an identity, such as shop.kettleandcrane.com. A trusted CA signs it after checking the binding is true.
Certificate authority (CA): An organization trusted to check identities and sign certificates with its private key, so others can trust the public keys inside those certificates. A company can also run its own private CA, as Alex does for Kettle & Crane's internal machines.
Chain of trust: The line of signatures from a leaf certificate up through intermediate CAs to a trusted root. If any link is missing, expired or untrusted, the browser shows a warning.
CIA triad: The three core security goals: confidentiality, integrity and availability. Cryptography mainly delivers confidentiality and integrity, plus non-repudiation.
Cipher suite: A named set of algorithms that a TLS connection agrees to use, such as TLS_AES_256_GCM_SHA384. The client lists the ones it supports and the server picks one.
Ciphertext: The scrambled, noise-like result of encryption. An eavesdropper who sees it cannot read it without the key.
Client Hello: The first message of a TLS handshake. The client lists the TLS versions and cipher suites it supports and sends its half of the ECDHE exchange.
CN (Common Name): The name in a certificate's subject, for example CN=shop.kettleandcrane.com. Browsers no longer rely on it and check the SAN instead.
Code signing: A vendor digitally signing its software or updates so users can check who published them and that they haven't been changed. The user's system verifies the signature with the vendor's public key before trusting the code.
Collision: Two different inputs that produce the same hash. Collisions must exist in theory, but a strong hash makes finding one infeasible.
Collision resistant: The property that finding two inputs with the same hash is infeasible. MD5 and SHA-1 lost this property, which is why they are retired.
Confidentiality: Keeping data readable only by the right people, such as only the 40 cafés reading the wholesale price list. Encryption provides it; hashing and signatures do not.
Credential stuffing: An attack that takes usernames and passwords stolen from one site and tries them automatically on many other sites. It works because people reuse passwords.
CRL (Certificate Revocation List): A signed list of the serial numbers of revoked certificates that a CA publishes. Clients download it to check whether a certificate has been killed early.
Cryptographic vulnerability: A weakness in how crypto is chosen, configured or managed, such as a retired algorithm, a reused nonce or a key left in code, rather than a flaw in the algorithm itself.
Cryptography: The science of protecting information with math, so only the right people can read or change it and the sender can be proven.
CSR (Certificate Signing Request): A file holding a public key and the requested name, signed by the matching private key, that a server sends to a CA to get a certificate. The private key never leaves the server.

D

Data at rest: Data stored on a disk, in a backup or in a database, as opposed to data moving over a network. Examples are a stolen laptop's drive or a copied database file.
Data in transit: Data moving across a network between systems. TLS protects it on the way, but the server can still read it once it arrives.
Database encryption: Encrypting a whole database file at rest, so a copied file is useless without the key. It decrypts for every query, so record-level encryption is still needed for the most sensitive fields.
Decryption: Turning ciphertext back into readable plaintext using the right key.
DES (Data Encryption Standard): An old symmetric cipher retired because its keys are too short. AES replaces it.
DHE / ECDHE: Diffie-Hellman with fresh random secrets for every exchange (ECDHE is the elliptic-curve version, used by modern TLS). Because the secrets are thrown away, it gives forward secrecy.
Diffie-Hellman: A key exchange method that lets two sides, like Alex and Bea, compute the same shared secret over an open line without ever sending it. It relies on math that is easy one way and infeasible to reverse.
Digital signature: A value made by transforming a message's hash with the sender's private key and checked with their public key. It gives integrity and non-repudiation, but not secrecy.
Discrete logarithm problem: The hard problem of recovering the secret exponent from a value like g^a mod p. Its difficulty with large numbers is what keeps Diffie-Hellman safe.
Downgrade attack: An attacker in the middle tampers with the Hello messages to force two sides onto an older, breakable protocol or cipher. TLS stops it by refusing old versions and by the Finished check.

E

ECB (Electronic Codebook): An unsafe block cipher mode that encrypts each block on its own, so identical plaintext blocks give identical ciphertext and patterns show through. Never use it.
ECC (Elliptic Curve Cryptography): The modern public-key family, based on points on an elliptic curve. It gives the same strength as RSA with much shorter keys: a P-256 key matches RSA-3072.
ECDSA (Elliptic Curve Digital Signature Algorithm): A signature algorithm that uses elliptic-curve keys. It signs with different math from RSA, but you still sign with the private key and verify with the public key.
Ed25519: An elliptic-curve algorithm that new systems increasingly prefer for signatures.
Encoding: Changing data into another format with a public, reversible rule and no key, such as base64. Anyone can undo it, so it gives no secrecy.
Encryption: Scrambling data with a key so only someone holding the right key can read it. It is the only option among encryption, encoding and obfuscation that gives real secrecy.
End-to-end encryption (E2EE): Data is encrypted on the sender's device and decrypted only on the recipient's device, so no server in between, not even the provider's, can read it. Signal works this way.
Ephemeral key: A key made fresh for one exchange and then thrown away. Because it no longer exists, it cannot be stolen later to unlock old sessions.

F

FileVault: Apple's full disk encryption for macOS.
Forward secrecy: Recorded sessions stay unreadable even if the server's long-term private key is stolen later, because each session key came from ephemeral secrets that are gone. This is why a café's old orders stay safe.
Full disk encryption (FDE): Encrypting an entire drive, including the operating system, so a powered-off or stolen machine shows only noise. It does not protect a running, logged-in machine.

G

GCM (Galois/Counter Mode): The modern default mode for AES. It gives both secrecy and integrity by adding an authentication tag, which makes it authenticated encryption.

H

Handshake: The opening exchange of a TLS connection, before any data flows. Client and server agree a version and cipher, run ECDHE, and check the server's certificate and signature.
Hardcoded secret: A key, API key or password written directly into source code, so anyone who reads the code has it. The fix is to rotate the secret, remove it from the code, and load it at run time.
Hash: A short, fixed-length fingerprint of data. The same input always gives the same hash, and any change gives a different one.
Hash function: A function that turns any input into a fixed-length hash. It is one-way, always the same length and collision resistant, and it uses no key.
HSM (Hardware Security Module): A dedicated, tamper-resistant device that stores keys and does crypto inside itself, so the key never leaves it in the clear.
HTTPS: Web traffic protected by TLS, as on the Kettle & Crane shop. It is a real example of hybrid encryption.
Hybrid encryption: Using asymmetric crypto to share or agree a key, then fast symmetric crypto (AES) to carry the actual data. TLS and large encrypted files work this way.
Hybrid key exchange: A key exchange that runs a classic method (ECDHE) and a post-quantum one (ML-KEM) together. The session key stays safe as long as either one is unbroken.

I

Integrity: Assurance that data has not been changed without you knowing, for example that nobody altered a price on the way. Hashes, signatures and GCM tags provide it.
Intermediate CA: A CA whose certificate is signed by the root and which signs everyday leaf certificates, so the root key can stay offline. If it is compromised, only the intermediate is revoked.
Issuer: The certificate field naming the CA that signed and issued the certificate. In a self-signed certificate it is the same as the subject.

J

John the Ripper: A password-testing tool defenders use to find weak passwords. It hashes each word in a word list with each stored salt and looks for matches.

K

Kerckhoffs's principle: A system should stay secure even if everything about it except the key is public. So you trust published algorithms like AES and never rely on a secret, home-made cipher.
Key: The secret value, really a long run of bits, that controls encryption and decryption. Change the key and you get different ciphertext.
Key distribution problem: The difficulty of getting a shared symmetric key to the other side, for example to Alex's offsite backup server, without an eavesdropper grabbing it. Asymmetric crypto and key exchange solve it.
Key escrow: Keeping a secure, recoverable copy of an encryption key with a trusted party, so company files can still be decrypted if an employee loses their key. It is never done for signing keys, because a second copy would break non-repudiation.
Key exchange: Two sides agreeing a shared secret key, often by computing it together over an open line so the key itself is never sent.
Key length: A key's size in bits. Each extra bit doubles the number of possible keys, which is why long keys defeat brute force.
Key management: Handling keys safely across their whole life: generate them securely, store them apart from the data, distribute them safely, rotate them, escrow encryption keys only, and revoke and destroy them at the end.
Key pair: A public key and a private key generated together and mathematically linked, so what one locks only the other opens.
Key rotation: Replacing a key on a schedule, and immediately after any suspected leak, so one exposed key reveals as little as possible.
Key stretching: Running password hashing through thousands or millions of rounds, so each guess takes a noticeable fraction of a second. That turns billions of guesses a second into thousands.
KMS (Key Management System): A system, often a cloud service, that generates, stores, rotates and controls access to keys in one central place. Alex keeps the backup key there.

L

Leaf certificate: The certificate for an actual server or user, such as intranet.kettleandcrane.com, signed by an intermediate CA. It sits at the bottom of the chain.
Long-term key: A server's lasting private key, the one tied to its certificate. In modern TLS it only proves the server's identity; it does not produce the session key, which is what gives forward secrecy.
LUKS: The standard disk and volume encryption on Linux, built on dm-crypt.

M

MD5: An old hash with a 128-bit (32 hex digit) output. It is broken by collisions, so it is unsafe for security and only rules out accidental corruption.
ML-DSA: NIST's post-quantum standard for making digital signatures, published as FIPS 204.
ML-KEM: NIST's post-quantum standard for agreeing keys, published as FIPS 203. TLS tools already offer it in a hybrid exchange alongside ECDHE.
Mode of operation: The rule for applying a block cipher across a whole message made of many blocks. ECB is unsafe, CBC is older, and GCM is the modern default.

N

NIST (National Institute of Standards and Technology): The US standards body whose guidance is widely used to choose algorithms and key lengths. It publishes numbered FIPS standards, including the post-quantum ML-KEM (FIPS 203) for key agreement and ML-DSA (FIPS 204) for signatures.
Non-repudiation: The sender cannot later deny having sent or approved something. If Jo signs a purchase order, only her private key could have made that signature.
Nonce: A non-secret value used only once per key, so encrypting the same plaintext twice gives different ciphertext. Never reuse a nonce with the same key in GCM, because doing so can leak the plaintext and key material.

O

OAEP (Optimal Asymmetric Encryption Padding): The safe padding scheme for preparing a message for RSA encryption. Always use it when encrypting with RSA.
Obfuscation: Making data or code harder for a person to understand, for example by renaming or shuffling things, without a real key. It is at most a speed bump and never security.
OCSP (Online Certificate Status Protocol): A live check where the client asks the CA's responder about one certificate and gets back "good", "revoked" or "unknown", instead of downloading a whole CRL.
OCSP stapling: The server attaches a fresh, CA-signed OCSP status to its connection, so the client doesn't need to ask the CA itself.
One-way: A hash cannot be worked back to its input, because it throws information away. This is why hashing is not encryption.
openssl: The free command-line crypto toolkit (OpenSSL 3) used throughout the labs to make keys, sign files, issue certificates and test TLS.
openssl ca: The openssl subcommand that runs a small CA. It signs CSRs into certificates, revokes them (-revoke) and publishes CRLs (-gencrl), recording everything in index.txt.
openssl req: The openssl subcommand that makes certificate requests. req -new makes a CSR, and req -x509 makes a finished self-signed certificate instead.
openssl s_client: The openssl subcommand that connects to a TLS server and prints what was negotiated: the protocol, the cipher and the certificate verify result.

P

P-256: Standard elliptic curves for ECC keys. P-256 gives about 128-bit strength, like RSA-3072, and P-521 gives about 256-bit strength.
Partition: A labeled slice of a disk. It can be encrypted on its own, for example to protect just the area holding customer data.
Password spraying: An attack that tries a few common passwords against many accounts, which keeps each account under its lockout limit. It succeeds whenever some users have picked weak, common passwords.
PBKDF2: A standards-based key-stretching function for passwords that is built into many systems.
PEM file: A text file format that stores keys and certificates as base64 between `-----BEGIN ...-----` and `-----END ...-----` lines. For example, `priv.pem` might hold a private key and `pub.pem` the matching public key.
PKI (Public Key Infrastructure): The whole system of CAs, certificates, keys and revocation that ties public keys to identities, so people and machines can trust whose key they are using. An organization can run a small private PKI for internal sites, like Kettle & Crane's intranet.
Plaintext: The readable data you start with before encryption, such as "House Espresso 5 lb $55".
Post-quantum: New algorithms designed to resist a future large quantum computer, which could break RSA and ECC. NIST's standards are ML-KEM for keys and ML-DSA for signatures.
Private key: The secret half of a key pair, which never leaves its owner's machine. It decrypts messages sent to you and makes your signatures.
Private PKI: A company's own CA, trusted only by its own machines. Alex uses one for internal names like intranet.kettleandcrane.com, which a public CA won't issue for.
Public key: The shareable half of a key pair, handed out freely. Others use it to encrypt to you and to verify your signatures.

R

Rainbow table: A huge precomputed table of common passwords and their hashes, so an attacker can read a password straight off an unsalted hash. Salting makes it useless.
RC4: An old stream cipher that is retired and should be avoided entirely.
Record-level encryption: Encrypting individual fields, columns or rows inside a database, such as customer phone numbers, while the rest stays readable. It protects those fields even from database users and SQL-injection dumps.
Renewal: Getting a fresh certificate, starting from a new CSR, before the current one expires. It is the normal end of the certificate lifecycle; revocation is the early, forced one.
Replay attack: An attacker captures a valid encrypted message, such as "transfer $100", and sends it again later without decrypting it. TLS stops this with fresh per-session keys and authenticated sequence numbers.
Retired algorithm: An algorithm or protocol no longer considered safe, such as MD5, SHA-1, DES, 3DES, RC4, SSL, TLS 1.0/1.1 or RSA-1024. Finding one in use is a cryptographic vulnerability to fix.
Revocation: A CA deliberately distrusting a certificate before its expiry date, for example after a key leak or a stolen laptop. Clients learn about it through a CRL or OCSP.
Root CA: The top CA of a PKI. Its self-signed root certificate sits in trust stores and its private key is kept offline, used only to sign intermediates.
Root of trust: The trusted root certificate at the top of a chain, which everything below it rests on.
RSA: The oldest common public-key algorithm, secure because factoring a product of two huge primes back into those primes is infeasible. It is slow and size-limited, and RSA-3072 or ECC is advised for new work.
RSA key transport: An older setup where the client encrypts the session key with the server's long-term RSA public key. It gives no forward secrecy, because stealing that key later unlocks every recorded session.

S

Salt: A random value, different for every password, added before hashing and stored openly beside the hash. It makes Priya's and Sam's identical passwords hash differently.
Salting: Adding a unique salt to each password before hashing. It defeats rainbow tables and the spotting of matching accounts, but it doesn't stop someone guessing a weak password.
SAN (Subject Alternative Name): The certificate field listing every name the certificate is valid for. Browsers check the URL against this field, not the CN.
Secret scanning: Automatically searching code for keys, passwords and API keys before it is committed, as Alex's grep for API_KEY does by hand.
Secrets manager: A secure service that programs load secrets from at run time, so the secrets are never written into code.
Security through obscurity: Relying on keeping the method secret instead of on a real secret key. It is not real security, because once the method leaks nothing is left to protect you.
Self-signed certificate: A certificate that signs itself, so its issuer and subject are the same and no CA vouches for it; browsers warn unless it is added to the trust store by hand. Root certificates are also self-signed, but vetted.
Serial number: The unique number a CA gives each certificate it issues. CRLs and OCSP identify revoked certificates by it.
Session key: A symmetric key used for only one conversation and then thrown away. Each new connection gets a fresh one from key exchange.
SHA-1: An old hash with a 160-bit (40 hex digit) output. It is broken by collisions and unsafe for security.
SHA-256: The everyday secure hash, which gives a 256-bit output written as 64 hex digits. Use it for file checks and signatures, but never alone for passwords.
SHA-3: A newer family of secure hash functions that is a safe alternative to SHA-256.
SHA-512: A secure hash with a larger output than SHA-256, also safe to use.
Shared secret: The value both sides of a key exchange end up with without ever sending it, like the 2 in the Diffie-Hellman example. It is then hashed to make the session key.
SSL (Secure Sockets Layer): The old predecessor of TLS. It is now switched off everywhere as unsafe.
Stream cipher: A symmetric cipher that encrypts data as a continuous stream of bits or bytes, not in fixed-size blocks. RC4 is an old stream cipher that is now retired and should be avoided.
Subject: The certificate field naming who the certificate is for, for example CN=shop.kettleandcrane.com.
Symmetric encryption: Encryption where one shared key both locks and unlocks. It is fast and ideal for bulk data like backups, but getting the key to the other side safely is the hard part.

T

TLS (Transport Layer Security): The protocol behind HTTPS, combining a certificate, an ECDHE key exchange, a signature and AES-GCM into one secure connection. Only TLS 1.2 and 1.3 are still safe to use.
TLS 1.3: The preferred TLS version. It always uses ephemeral key exchange, giving forward secrecy, and finishes the handshake in a single round trip.
TPM (Trusted Platform Module): A chip on a computer that holds a disk-encryption key and releases it only to that machine at boot. Full disk encryption often uses it.
Trust store: The built-in list of CAs that an operating system or browser trusts out of the box. Alex adds Kettle & Crane's root.crt to company laptops' trust stores.
Two-tier CA: A PKI where an offline root CA signs only an intermediate CA, and the intermediate signs everyday certificates. If the intermediate's key is compromised, you revoke just the intermediate and the root stays trusted.

V

Validity: The certificate's "not before" and "not after" dates. Outside that window the certificate is invalid, and expiry is the most common cause of a sudden browser warning.
Volume: A usable storage area that the operating system mounts, often one partition. It can be encrypted on its own.
VPN (virtual private network): An encrypted tunnel between networks or devices that protects traffic crossing untrusted networks like the internet. VPNs commonly use AES to encrypt the data.

W

Weak or default credentials: Keys or passwords that are short, guessable or left at the factory setting, such as a device shipped with admin/admin. They are a cryptographic vulnerability however strong the algorithm is.
Weak randomness: Keys, nonces or salts that come from a predictable source, such as the time or a fixed seed, instead of a secure one like os.urandom. If attackers can guess the value, the whole scheme falls.
Wildcard certificate: A certificate like *.kettleandcrane.com that covers every subdomain exactly one level down. One key then protects many hosts, so a leak exposes them all.
Work factor: The bcrypt setting for how many rounds to run, where 10 means 2^10. Raise it as computers get faster, aiming for about 0.1-0.5 seconds per hash.

X

X.509: The standard format for certificates. It defines fields such as subject, SAN, public key, issuer, validity and the issuer's signature.