Skip to content
LumenaryAcademy
Engineering 85 min

Applied cryptography

Hashes, MACs, ciphers and signatures — what each guarantees, how TLS combines them, and why you should not build your own.

Code tested · 7AI-draftedAwaiting review by a computer scientist

Your guides: Chloe · The Computer Scientist, Margaret · The Experimenter, Gideon · The Verifier

MotivationH

Secrets over an open channel

Every time you load a web page over HTTPS, send a message, pay by card, install a software update or push a signed commit, cryptography is doing something remarkable: letting two parties who may never have met communicate securely over a network that anyone can watch and some can tamper with.

Modern cryptography rests on mathematics that has held up to decades of public attack, and the primitives in your standard library are, used correctly, far stronger than any attacker's budget. Yet systems using cryptography are broken all the time. Almost never is it because AES or SHA-256 failed. It is because a nonce was reused, a comparison leaked timing, a random number was predictable, a message was encrypted but not authenticated, or a certificate was not checked. Applied cryptography is mostly the art of using sound primitives correctly, and knowing which primitive provides which guarantee.

This lesson builds that map: hash functions, message authentication codes, symmetric encryption, key exchange, public-key encryption and signatures, then how TLS assembles them and how the field is preparing for quantum computers. The mathematics behind the public-key parts — modular arithmetic, groups, primes — is developed properly in Lumenary Math's Cryptography and Modular arithmetic; here we use it.

DefinitionsH

Goals and adversaries

Definition— Cryptographic goals

Confidentiality: only the intended parties can read a message. Integrity: any change to a message is detected. Authenticity: the recipient can verify who sent the message. A digital signature adds non-repudiation: a third party can verify the sender, so the sender cannot later deny it.

These goals are always stated against an adversary. A passive adversary only reads traffic — a Wi-Fi eavesdropper. An active adversary can also modify, drop, replay and inject messages — a compromised router, a malicious proxy — and can sit between two parties pretending to each to be the other (a machine-in-the-middle). Much of what makes protocols subtle is defending against the active adversary.

Two principles frame everything. Kerckhoffs's principle: a system must remain secure when everything about it except the key is public. The algorithms in this lesson are all public, standardised and studied by thousands of researchers; only keys are secret. And security levels: a scheme has "128-bit security" if the best known attack needs about 21282^{128} operations. For scale, 2128≈3.4×10382^{128} \approx 3.4 \times 10^{38}; a billion computers each doing a billion operations per second would need about 101310^{13} years. Symmetric keys of 128 or 256 bits are therefore enough against classical computers; public-key systems need larger numbers for the same level (around 3072-bit RSA, or 256-bit elliptic curves, for 128-bit security), because the best attacks on them are cleverer than brute force.

ComputationC

Hash functions

A cryptographic hash function maps input of any length to a fixed-size digest — 256 bits for SHA-256 — and is designed so that:

  • Preimage resistance: given a digest hh, finding any input xx with H(x)=hH(x) = h is infeasible.
  • Second-preimage resistance: given an input xx, finding a different x′x' with H(x′)=H(x)H(x') = H(x) is infeasible.
  • Collision resistance: finding any two different inputs with the same digest is infeasible.

Hash tables (Hash tables) need none of these; Git's content addressing (Version control) needs all of them. Collisions are easier to find than preimages because of the birthday paradox: among kk random nn-bit digests there are about k2/2k^2/2 pairs, each colliding with probability 2−n2^{-n}, so a collision becomes likely around k≈2n/2k \approx 2^{n/2}. A 256-bit hash therefore offers 128-bit collision resistance. Watch both effects on SHA-256, and on a deliberately truncated version:

python
import hashlib

def sha256_hex(data):
    return hashlib.sha256(data).hexdigest()

a, b = b"Pay Nadia 100 shillings", b"Pay Nadia 900 shillings"
ha, hb = hashlib.sha256(a).digest(), hashlib.sha256(b).digest()
differing_bits = sum(bin(x ^ y).count("1") for x, y in zip(ha, hb))
print(sha256_hex(a))
print(sha256_hex(b))
print(f"one character changed -> {differing_bits} of 256 output bits differ (the avalanche effect)")

# The birthday bound: truncate SHA-256 to 24 bits and search for a collision.
def tiny_hash(data, bits=24):
    return int.from_bytes(hashlib.sha256(data).digest(), "big") >> (256 - bits)

seen = {}
i = 0
while True:
    message = f"message number {i}".encode()
    h = tiny_hash(message)
    if h in seen:
        print(f"24-bit collision after {i + 1} messages: {seen[h]!r} and {message!r}")
        break
    seen[h] = message
    i += 1
print(f"birthday estimate: about 2**12 = {2**12} messages; a preimage would need about 2**24 = {2**24:,}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Uses of hash functions in practice include verifying downloads against a published digest (if you trust the source of the digest), content-addressed storage, commitments, and as building blocks inside MACs, signatures and key derivation. MD5 and SHA-1 are broken for collision resistance — practical collisions exist — and must not be used where collisions matter; SHA-256, SHA-512 and SHA-3 are current. Remember too that a plain hash is the wrong tool for passwords, which need the slow, salted functions from Security fundamentals.

ComputationC

Message authentication codes

A hash proves integrity only if the digest itself arrives through a trusted channel: an active attacker who changes a message can simply recompute its hash. To authenticate messages over an untrusted channel, sender and receiver share a secret key and use a message authentication code (MAC): a tag computed from the key and the message, which nobody without the key can forge for any new message.

The obvious construction, sha256(key + message), is broken for SHA-256: because of the way SHA-2 processes messages in blocks, anyone who sees one valid tag can compute a valid tag for the message with extra data appended, without knowing the key (a length-extension attack). The standard construction HMAC hashes twice with derived keys and is secure for any good hash function. A very common use is a service that calls your web server (a "webhook") and signs each request so you can tell genuine calls from forged ones:

python
import hashlib
import hmac
import json
import secrets

shared_key = secrets.token_bytes(32)              # agreed once, out of band

def sign(key, body):
    return hmac.new(key, body, hashlib.sha256).hexdigest()

def verify(key, body, tag):
    return hmac.compare_digest(sign(key, body), tag)  # constant-time comparison

body = json.dumps({"order": 7781, "status": "paid", "amount_cents": 125000}).encode()
tag = sign(shared_key, body)

print("genuine request:  ", verify(shared_key, body, tag))
tampered = body.replace(b"125000", b"1250000")
print("amount changed:   ", verify(shared_key, tampered, tag))
print("attacker's key:   ", verify(secrets.token_bytes(32), body, tag))
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Two details are easy to get wrong. Compare tags with hmac.compare_digest, never ==: an ordinary comparison stops at the first differing character, and the time it takes can leak how many leading characters of a forged tag were right. And a valid MAC proves a message is authentic, not that it is fresh: an attacker can resend yesterday's genuine "paid" message. Real webhook schemes therefore sign a timestamp or unique ID along with the body and reject old or repeated ones.

ExplanationH

Symmetric encryption

Symmetric encryption uses one shared key to encrypt and decrypt. The workhorse is AES (the Advanced Encryption Standard, FIPS 197), a block cipher: a keyed permutation of 128-bit blocks, with 128- or 256-bit keys, implemented in hardware on nearly every modern processor. A block cipher alone encrypts one block; a mode of operation extends it to messages of any length, and the choice of mode matters enormously. The naive mode, ECB, encrypts each block independently, so identical plaintext blocks give identical ciphertext blocks and patterns in the data shine through.

The modern rule is simple: use authenticated encryption with associated data (AEAD), which provides confidentiality and integrity in one operation. AES-GCM and ChaCha20-Poly1305 are the standard choices. Encryption takes a key, a nonce (a number used once), the plaintext, and optional associated data that is authenticated but not encrypted (a header, a record ID); decryption fails loudly if anything was modified. With the cryptography library it looks like this:

python
import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = AESGCM.generate_key(bit_length=256)
aead = AESGCM(key)
nonce = os.urandom(12)                                  # never reuse with the same key
ciphertext = aead.encrypt(nonce, b"patient 1043: allergic to penicillin", b"record-1043")
plaintext = aead.decrypt(nonce, ciphertext, b"record-1043")   # raises InvalidTag if tampered

Why insist on authentication? Because encryption alone does not prevent tampering. Many modes, including the counter mode inside GCM, encrypt by XOR-ing the message with a keystream; flipping a bit of the ciphertext flips the same bit of the plaintext, so an attacker who knows the format can change "100" to "900" without decrypting anything. And the nonce must never repeat under one key: two messages encrypted with the same key and nonce share a keystream, which leaks their XOR, and in GCM also lets an attacker forge messages. The next block demonstrates the keystream problem with a toy cipher built for this purpose only.

python
import hashlib

def toy_keystream(key, nonce, length):
    """A teaching toy (SHA-256 in counter mode). Never use home-made ciphers for real data."""
    out = b""
    counter = 0
    while len(out) < length:
        out += hashlib.sha256(key + nonce + counter.to_bytes(8, "big")).digest()
        counter += 1
    return out[:length]

def xor(a, b):
    return bytes(x ^ y for x, y in zip(a, b))

key = b"a 32-byte key known to both ends"
nonce = b"nonce-0001"
m1 = b"Meet at the north gate at 06:00"
m2 = b"Transfer 4,000 to account 55-21"
c1 = xor(m1, toy_keystream(key, nonce, len(m1)))
c2 = xor(m2, toy_keystream(key, nonce, len(m2)))       # the mistake: same key, same nonce

print("c1 xor c2 == m1 xor m2:", xor(c1, c2) == xor(m1, m2))
print("an eavesdropper who guesses m1 recovers m2:", xor(xor(c1, c2), m1).decode())

flipped = bytearray(c2)
flipped[9] ^= ord("4") ^ ord("9")                       # flip bits, no key needed
print("tampered decryption:", xor(bytes(flipped), toy_keystream(key, nonce, len(m2))).decode())
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The eavesdropper never learned the key, yet recovered a message and altered another — exactly why protocols use AEAD with unique nonces, and why libraries make nonce handling hard to get wrong.

ComputationC

Key exchange, RSA and signatures

Symmetric cryptography assumes both sides already share a key. For two strangers on the internet, getting that key to both of them is the hard part. Public-key cryptography, invented in the 1970s, solves it.

Diffie–Hellman key exchange. Alice and Bob agree publicly on a large prime pp and a base gg. Alice picks a secret aa and sends A=ga mod pA = g^a \bmod p; Bob picks a secret bb and sends B=gb mod pB = g^b \bmod p. Each can now compute the same number, because

Ba≡(gb)a=gab=(ga)b≡Ab(modp).B^a \equiv (g^b)^a = g^{ab} = (g^a)^b \equiv A^b \pmod p .

An eavesdropper sees pp, gg, AA and BB, and to get gabg^{ab} appears to need the discrete logarithm aa of AA, which for well-chosen 2048-bit primes, or for elliptic-curve groups, is infeasible. (The algebra is that of a cyclic group; see Groups.) Note that plain Diffie–Hellman defeats only passive eavesdroppers: an active attacker in the middle can run one exchange with Alice and another with Bob. The fix is to authenticate the exchange with signatures, as TLS does.

RSA. Choose two large primes p,qp, q, let n=pqn = pq and φ=(p−1)(q−1)\varphi = (p-1)(q-1), pick ee coprime to φ\varphi, and compute d≡e−1(modφ)d \equiv e^{-1} \pmod{\varphi}. The public key is (n,e)(n, e); the private key is dd. Because ed≡1(modφ)ed \equiv 1 \pmod \varphi, Euler's theorem gives (me)d≡m(modn)(m^e)^d \equiv m \pmod n, so raising to the power ee and to the power dd undo each other. Anyone can compute with ee; only the holder of dd can invert it — and finding dd from (n,e)(n, e) appears to require factoring nn.

Digital signatures use this asymmetry the other way round: the signer applies the private operation to a hash of the message, and anyone can check the result with the public key. A valid signature proves the message came from the key holder and was not modified — authenticity, integrity and non-repudiation. Here are both ideas with numbers small enough to read, and a demonstration of why real keys are huge:

python
import hashlib
from math import gcd

# --- Diffie-Hellman with a toy prime ---------------------------------------
p, g = 7919, 7
a, b = 3001, 4512                         # Alice's and Bob's secrets (real ones are random and huge)
A, B = pow(g, a, p), pow(g, b, p)         # sent in the clear
print("Diffie-Hellman: A =", A, " B =", B)
print("  Alice computes", pow(B, a, p), "and Bob computes", pow(A, b, p))
x = next(x for x in range(p) if pow(g, x, p) == A)          # Eve brute-forces a log
print("  Eve finds an exponent", x, "for A, so she also gets", pow(B, x, p))

# --- RSA signatures with toy primes ----------------------------------------
P, Q, e = 101, 113, 17
n, phi = P * Q, (P - 1) * (Q - 1)
assert gcd(e, phi) == 1
d = pow(e, -1, phi)                       # modular inverse (Python 3.8+)
print(f"\nRSA: public key (n={n}, e={e}), private key d={d}")

def digest_mod_n(message):                # hash-then-sign (toy: reduce the hash mod n)
    return int.from_bytes(hashlib.sha256(message).digest(), "big") % n

def sign(message):
    return pow(digest_mod_n(message), d, n)

def verify(message, signature):
    return pow(signature, e, n) == digest_mod_n(message)

msg = b"release v2.4.1, sha256 9f6c..."
s = sign(msg)
print("  signature:", s, "  valid:", verify(msg, s), "  for a changed message:", verify(b"release v2.4.2", s))

# Factoring n by trial division takes microseconds at this size, and then the key is gone.
f = next(k for k in range(2, n) if n % k == 0)
forged_d = pow(e, -1, (f - 1) * (n // f - 1))
print(f"  Eve factors n = {f} x {n // f} and recovers d = {forged_d}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Real deployments differ from these toys in ways that matter. Keys are enormous (RSA moduli of 2048–4096 bits) or use elliptic curves (X25519 for key exchange, Ed25519 or ECDSA for signatures), which give the same security with much smaller keys and faster operations. And "textbook" RSA, as above, is insecure for encryption — it is deterministic and malleable — so real systems use padding schemes (OAEP for encryption, PSS for signatures) or, increasingly, avoid RSA encryption altogether in favour of Diffie–Hellman-based key agreement.

Worked examplesH

Putting it together: TLS 1.3

TLS (Transport Layer Security) is the protocol beneath HTTPS and much else; version 1.3 (RFC 8446) simplified and strengthened it. Its handshake combines every primitive in this lesson in one round trip:

ClientServerClientHello: versions, cipher suites, key share (X25519 …)ServerHello: chosen suite, server's key share{Certificate, CertificateVerify (signature), Finished (MAC)}{Finished (MAC)}{application data, both directions}
The TLS 1.3 handshake (simplified). Braces mark messages already encrypted with keys derived from the key exchange.
  1. Key exchange. The client's first message already carries a Diffie–Hellman key share, usually on the X25519 curve; the server answers with its own. Both derive the same secret, and from it, through a key-derivation function built on HMAC, separate encryption keys for each direction. Everything after the ServerHello is encrypted.
  2. Server authentication. The server sends its certificate — its public key and domain name, signed by a certificate authority — and a CertificateVerify message: a signature, with its private key, over the whole handshake so far. The client checks the certificate chain up to a root it trusts, checks that the name matches the site it wanted, and checks the signature. This is what defeats the machine-in-the-middle: an attacker can perform a key exchange, but cannot sign as the real server.
  3. Handshake integrity. Each side sends a Finished message, a MAC over the entire handshake transcript, so any tampering with the negotiation (for example, forcing weaker options) is detected.
  4. Data. Application data is protected with an AEAD cipher, AES-GCM or ChaCha20-Poly1305, with nonces derived from a record counter so they never repeat.

Because the Diffie–Hellman keys are freshly generated for each connection and then discarded, recorded traffic stays safe even if the server's long-term private key is stolen later: forward secrecy, which TLS 1.3 makes mandatory. The certificate system, with its certificate authorities and the public Certificate Transparency logs that record every certificate issued, is the part of the system that establishes trust; free automated certificate authorities such as Let's Encrypt made HTTPS the default on the web.

ExplanationH

Post-quantum cryptography

A sufficiently large, fault-tolerant quantum computer running Shor's algorithm (1994) could factor integers and compute discrete logarithms efficiently, breaking RSA, Diffie–Hellman and elliptic-curve cryptography — essentially all public-key cryptography deployed today. Symmetric cryptography is far less affected: Grover's algorithm gives at most a square-root speed-up on brute-force search, so AES-256 and SHA-256-based constructions remain secure with their current sizes. As of 2026, no quantum computer is anywhere near large enough to threaten real keys, and estimates of when one might be vary widely.

Why act now, then? Because of "harvest now, decrypt later": an adversary can record encrypted traffic today and decrypt it when a quantum computer exists. Data that must stay secret for decades — medical, diplomatic, commercial — is already exposed to that risk. Signatures are less urgent, since a forged signature only matters once a quantum computer exists, but the systems that rely on them (firmware, certificates) take many years to change.

After an open, eight-year international competition, NIST published its first three post-quantum standards in August 2024:

StandardAlgorithmPurposeBased on
FIPS 203ML-KEM (from CRYSTALS-Kyber)key establishmentmodule lattices
FIPS 204ML-DSA (from CRYSTALS-Dilithium)digital signaturesmodule lattices
FIPS 205SLH-DSA (from SPHINCS+)digital signatureshash functions only

Lattice-based schemes rest on problems such as learning with errors: recovering a secret vector from many noisy linear equations, which is believed to be hard even for quantum computers. Hash-based signatures rest only on the security of hash functions, a very conservative assumption, at the cost of larger signatures. NIST has also announced further algorithms to standardise, including a signature scheme based on Falcon (FN-DSA) and, in 2025, the code-based HQC as a backup key-establishment mechanism; see the NIST PQC project for the current state.

Deployment is already under way, and it is hybrid: TLS key exchange combines classical X25519 with ML-KEM-768, so the connection is secure as long as either holds. Major browsers and content-delivery networks, and increasingly operating systems' own TLS libraries, have enabled hybrid post-quantum key exchange by default, and by 2025 a large share of web traffic was already protected this way. The engineering lessons for your own systems: inventory where you use public-key cryptography, prefer protocols and libraries that can switch algorithms (crypto agility), and migrate key establishment for long-lived secrets first.

ExplanationH

Don't roll your own crypto

The rule is famous because the failures are so consistent. Cryptographic code can pass every functional test — it encrypts, it decrypts, the round trip works — and still be completely insecure, because security is a property against an adversary, which ordinary tests do not model. Real-world failures from well-funded teams include:

  • Bad randomness. A change made to Debian's OpenSSL package in 2006, and discovered only in 2008, removed most of the entropy from key generation, so for nearly two years affected systems generated keys from a space small enough to enumerate.
  • Nonce reuse. In 2010 researchers showed that a games console's code-signing used the same random value in every ECDSA signature, which let them compute the platform's private signing key.
  • Side channels. Timing differences, cache behaviour and error messages have leaked keys from implementations of mathematically sound algorithms many times.
  • Protocol design. Combining sound primitives in a new protocol is where experts most often go wrong; TLS itself needed years of attacks and revisions to reach version 1.3.

What to do instead:

  • Use the highest-level tool that fits. For data in transit, use TLS. For messaging, use an established protocol. For encrypting data at rest, use a high-level library recipe such as libsodium's secretbox, Google's Tink, or cryptography's Fernet, which choose the algorithms, generate nonces and authenticate for you.
  • Use secrets (or os.urandom) for keys, tokens and nonces, never random, which is predictable by design.
  • Do not design protocols without review by people who do this for a living, and treat any custom cryptography as a high-risk component that needs external audit.
  • Plan for change. Record which algorithms protect what, so you can rotate keys and replace algorithms when needed, as the post-quantum transition now requires.

"Don't roll your own" does not mean "don't learn how it works". Understanding the primitives, as in this lesson, is exactly what lets you choose the right library, configure it correctly, and recognise misuse in a code review.

Common misconceptionsH

Common misconceptions

Misconception

"Encrypted means tamper-proof." Encryption without authentication is malleable: the toy demonstration changed a transfer amount without the key. Use authenticated encryption (AEAD), or add a MAC.

Misconception

"Hashing is a kind of encryption." Encryption is reversible with a key; hashing has no key and is not reversible. And Base64 is neither: it is an encoding that anyone can undo.

Misconception

"Longer keys are always better." Beyond the 128- or 256-bit security level, longer keys add cost without meaningful protection, and key lengths are not comparable across algorithms: a 256-bit elliptic-curve key is about as strong as a 3072-bit RSA key. Choose a security level, then the standard parameters for it.

Misconception

"Quantum computers will break all cryptography." Shor's algorithm breaks today's public-key schemes; symmetric ciphers and hash functions only need adequate sizes (AES-256 and SHA-256 are fine). Post-quantum public-key algorithms are standardised and already deployed.

History & global context

A short history

For most of history cryptography was a military and diplomatic craft of substitution and transposition ciphers, from Caesar's shifted alphabet to the Vigenère cipher and the rotor machines of the twentieth century; breaking the German Enigma at Bletchley Park, with key contributions from Polish mathematicians and from Alan Turing, shaped the Second World War. The modern, public science began in the 1970s: the Data Encryption Standard (1977); Whitfield Diffie and Martin Hellman's "New Directions in Cryptography" (1976), which introduced public-key cryptography and key exchange; and RSA, devised by Ron Rivest, Adi Shamir and Leonard Adleman in 1977. It later emerged that James Ellis, Clifford Cocks and Malcolm Williamson at Britain's GCHQ had discovered equivalent ideas a few years earlier, in secret. AES, designed by the Belgian cryptographers Joan Daemen and Vincent Rijmen, won an open NIST competition and was standardised in 2001; SHA-3 followed a similar competition in 2015, and the post-quantum standards of 2024 continued the tradition of open, international competitions.

Exercises

Exercises

1. Applied cryptography

Warm-upHuman

A storage system names each file by the first 64 bits of its SHA-256 digest. Treating digests as random, roughly how many files can it hold before an accidental collision between two of them becomes likely? Answer with the exponent kk in 2k2^k.

2. Applied cryptography

CoreComputational

A payments service calls your server with a JSON body (bytes) and a header such as t=1767225600,v1=5f2b…. Here t is the Unix time when the request was signed and v1 is the hex HMAC-SHA256, under your shared secret, of the bytes b"<t>." + body (the timestamp, a full stop, then the body). Write verify(secret, body, header, now, tolerance=300) that returns True only if the signature is valid and t is within tolerance seconds of now (in either direction). It must return False, not raise, for a malformed header, and compare signatures in constant time.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

3. Applied cryptography

CoreComputational

Implement textbook RSA with tiny numbers.

  • make_keys(p, q, e) returns ((n, e), (n, d)), the public and private keys, where n=pqn = pq and dd is the inverse of ee modulo φ=(p−1)(q−1)\varphi = (p-1)(q-1). Raise ValueError if ee is not coprime to φ\varphi.
  • rsa_sign(m, private_key) returns md mod nm^d \bmod n for an integer 0≤m<n0 \le m < n.
  • rsa_verify(m, s, public_key) returns whether se mod n=ms^e \bmod n = m.

(Real RSA uses primes hundreds of digits long, hashes the message, and pads it; this is only the arithmetic core.)

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

4. Applied cryptography

StretchComputational

Diffie–Hellman is only as strong as the discrete logarithm problem in its group. Write discrete_log(g, h, p) for a prime p: return an integer x≥0x \ge 0 with gx≡h(modp)g^x \equiv h \pmod p, or None if there is none. The tests use p=10 000 000 259p = 10\,000\,000\,259, so trying every exponent (about 101010^{10} of them) is far too slow. Use the baby-step giant-step algorithm, which needs about p\sqrt{p} steps and memory: with m=⌈p−1⌉m = \lceil \sqrt{p-1} \rceil, write x=im+jx = im + j with 0≤i,j<m0 \le i, j < m; store gjg^j for every jj in a dictionary, then check h⋅g−imh \cdot g^{-im} for i=0,1,…i = 0, 1, \dots.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

6. Applied cryptography

CoreHuman

A service encrypts records with AES-GCM under one long-lived key, using a nonce from a counter that is stored in memory. After a restart the counter starts again at zero. What follows?

Choose one

7. Applied cryptography

CoreHuman

In a TLS 1.3 handshake, what does the server's certificate together with its CertificateVerify signature accomplish?

Choose one

8. Applied cryptography

StretchHuman

A hospital network wants to begin its post-quantum migration. Which first step does the reasoning in the lesson support best?

Choose one

Further reading and resources