TLS Lecture 1 · Why TLS Exists: the Open Network, the Threat Model, and 25 Years of Broken SSL

The first of three lessons rebuilt from the Security I TLS lecture. It recaps the three uses of public-key crypto on a hand-computed RSA key, follows a login across every machine between a cafe and a bank to show why plaintext is a postcard, sorts real incidents (Firesheep, the Great Cannon, a fake airport hotspot) into read, change and pretend, states the TLS threat model and its three guarantees, then walks through every SSL and TLS version as the design flaw that retired it and the fix that followed, ending with how compatibility kept broken versions alive and how to configure and verify a server that accepts only TLS 1.2 and 1.3.

Subject: Computer Security · 67 slides · code lesson

Open the interactive version of this deck

What this lesson covers

The lesson, slide by slide

1. Why TLS Exists: the Open Network, the Threat Model, and 25 Years of Broken SSL

Title

Computer Security — TLS Lecture 1

Public-key crypto works. Now put it on a network that someone else owns.

2. Part 1 — Where the last lecture left us

Section

Public-key crypto works; whose key is it?

3. What you will be able to do

Objectives

The cryptography lecture ended with a working public-key toolkit and one unsolved problem: you cannot tell whose public key you are holding. TLS is the answer the whole Internet deployed. This first part sets the stage: why a secure channel is needed at all, exactly what it has to promise, and what went wrong in every version before the current one.

Security I, Lecture 3: TLS and the Web PKI slide s-title

4. Warm-up: what problem did public-key crypto solve?

Warm-up

Before public-key crypto, every scheme in the cryptography lecture had the same precondition.

Discussion prompt

What did AES and HMAC need before the first message, and how does a public key remove that need? What new problem does it leave behind?

Hint: What has to exist before Alice sends anything, and what can Mallory substitute?

Answer:

They needed a secret key already shared by both sides. A public key removes that: Bob publishes one half of a key pair, anyone can lock a message to him with it, and only his private half unlocks it. Nothing secret is arranged in advance.

The problem left behind is authenticity of the key itself. A public key is just a number. If Mallory hands you her own padlock and says it is Bob's, you will lock your secret to Mallory. Most of this TLS series is about that one question.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-pk

5. Recap: the public key is an open padlock

Concept

Bob generates a matched key pair, publishes the public key PK and keeps the private key SK. Anyone can snap the padlock shut, which is encryption with PK. Only SK opens it.

Figure (svg): Bob's KeyGen makes PK for anyone and SK for Bob; Alice encrypts with PK; Mallory on the wire holds PK and the ciphertext and still cannot open it

Mallory, on the wire, holds both the padlock and the locked box, and neither lets her open it. The one hard part flagged in red is today's subject: making sure the padlock you grabbed is really Bob's.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-pk

6. Recap, use 1: send the instructor a private message

Concept

The instructor posts a public key once. Any student encrypts with it, and only the instructor, holding the private key, can read the result. Nobody arranged anything in advance.

with AESwith a public key
setup before the first messagea secret key shared with every studentpost one public key
a 300-student class300 secrets delivered securelynothing delivered secretly
who can read a student's messageanyone holding that shared keyonly the private-key holder

AES could protect the message too, but only after a separate secret was set up with each student. Public key removes the setup, which is the whole point.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-use1

7. Recap, use 2: a signed announcement

Concept

Run it the other way. The instructor signs an announcement with the private key, and every student checks it with the public key. Only the private-key holder could have produced a valid signature.

propertyMAC (shared key)signature (key pair)
who can create a valid tageveryone who can verifyonly the private-key holder
who can verifyonly holders of the shared keyanyone with the public key
proof to a third partynoneyes: non-repudiation

A MAC cannot do this job: any student able to check the tag could also forge one, and could never prove to anyone else who wrote it. Certificates and software signing live on this row of the table, and so does a TLS server proving who it is.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-use2

8. Recap, use 3: two strangers end up with the same key

Concept

The most common use. A student picks a fresh random AES key k, locks it with the instructor's public key and sends it. Eve sees only the locked value. Both sides now hold k without ever having met, and they switch to AES for the real traffic.

Figure (svg): The student encrypts a random key k with PK and sends it; the instructor decrypts to get k; then both use AES with k in both directions

Why not use public key for everything? It is 100 to 1000 times slower than AES, so it only sets up k. This simple version, key transport, is how TLS 1.2 with RSA worked. Modern TLS uses Diffie-Hellman for the same job, which the next lecture builds.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-use3

9. Which use of public-key crypto is this?

Sorting

Sort each scenario by the job public-key crypto does in it.

Sort into buckets

Private message, signature, or key agreement?

private message
A whistle-blower sends a file only one journalist can open
signature
The bank's server proves to the browser that it really is the bank; Your phone checks an app update really came from the developer
key agreement
A browser and a bank's server that have never met set up an AES key for one visit; An SSH client and server derive fresh keys at the start of a login
conf
Only the private-key holder can read it; anyone could have sent it.
sig
Only the private-key holder could have produced it, and anyone can check it: proof of origin, not secrecy.
kex
Public key sets up a shared symmetric key once, and AES carries the data after that.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-use3

10. Recap: build an RSA key pair by hand

Worked example

RSA is a key factory. Run it on the classic tiny example so every number can be checked: primes 61 and 53. Blue values in the figure are public, yellow ones secret.

p, q   = 61, 53                 # two random primes (real ones: ~300 digits each)
n      = p * q                  # 3233, goes in the public key
phi    = (p - 1) * (q - 1)      # 3120, easy only if you know p and q
e      = 17                     # must share no factor with phi
d      = pow(e, -1, phi)        # 2753, the trapdoor
public  = (e, n)                # (17, 3233)
private = d                     # 2753; now delete p, q, phi
stepvaluepublic or secret
choose p and q61 and 53secret
n = p times q3233public
phi = 60 times 523120secret
choose e17public
d with e times d leaving remainder 1 mod 31202753secret

Figure (svg): p = 61 and q = 53 give n = 3233 and phi = 3120; e = 17 and d = 2753; factoring n back to p and q is the hard direction

Publish and delete

Why: The public key is (17, 3233) and the private key is 2753. Once d exists, p, q and phi are thrown away; anyone who learns phi or p can recompute d. Real keys use e = 65537 and a 2048-bit n.

Verify: e times d

Why: 17 times 2753 is 46801, which is 15 times 3120 plus 1, so d really does invert e mod 3120. In Python, pow(17, -1, 3120) returns 2753.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-rsa

11. Why must e share no factor with phi?

Socratic

The recipe says to pick e with no factor in common with phi = 3120. Try e = 2.

Discussion prompt

With e = 2, can any d satisfy e times d = 1 more than a multiple of 3120? What does that tell you about the rule?

Hint: Is 2 times anything ever odd?

Answer:

No. 2 times d is always even, and every multiple of 3120 is even, so 2d is never one more than a multiple of 3120. No d exists, so there is no private key and the scheme cannot decrypt.

In general an inverse of e mod phi exists exactly when e and phi share no factor. That is why 17 works (3120 = 2 times 2 times 2 times 2 times 3 times 5 times 13 has no factor 17) and why the standard choice 65537, a prime, almost always works.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-rsa

12. The RSA symbols, and who may see each one

Concept

A cheat sheet so the letters stop blurring together. Everything splits into two piles: what rides on the wire, and what never leaves the owner.

symbolwhat it isrelationwho sees it
p, qthe two prime factorschosen at randomsecret
nthe modulusn = p times qpublic
phiEuler's totient of n(p - 1) times (q - 1)secret
eencryption exponentno common factor with phipublic
ddecryption exponente times d is 1 mod phisecret
(e, n)public keyencrypt, verifypublic
(d, n)private keydecrypt, signsecret

Memory hook: the secret pile is everything needed to build the key (p, q and phi) plus the trapdoor d. Only n and e are ever published.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-symbols

13. Public or secret?

Discrimination

A server is about to put some RSA values in a message to the world.

Sort into buckets

Which values may it publish, and which must never leave it?

publish
n = 3233; e = 17
never publish
d = 2753; phi = 3120; p = 61
pub
n and e form the public key; publishing them is the whole point.
sec
d is the private key outright, and phi or either prime lets anyone recompute d in one line.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-symbols

14. Recap: one key, all three jobs, with real numbers

Worked example

Same key: n = 3233, e = 17, d = 2753. Watch it do every job, then keep two of them in mind for the rest of the series.

n, e, d = 3233, 17, 2753
pow(65, e, n)     # 2790  use 1: encrypt m = 65; only d undoes it
pow(2790, d, n)   # 65
pow(123, d, n)    # 2746  use 2: sign h = 123 (think: a hash)
pow(2746, e, n)   # 123   anyone verifies with the public e
# use 3: the student picks k = 65, sends 2790, the instructor recovers 65
jobwho computesinputoutput
1. private messageanyone, with em = 65c = 2790
1. read itonly the owner, with d279065
2. signonly the owner, with dh = 123s = 2746
2. verifyanyone, with e2746123: matches
3. key transportstudent locks k = 65652790, opened to 65

Figure (svg): Three lanes: 65 encrypts to 2790; 123 signs to 2746; key 65 travels as 2790; TLS needs the signature and the key-agreement lanes

What TLS takes from this

Why: TLS needs two of these: use 2 lets the server prove it is really Chase, and use 3, or its cousin Diffie-Hellman, gives both sides a shared key.

Verify: in Python

Why: pow(65, 17, 3233) returns 2790, pow(2790, 2753, 3233) returns 65, pow(123, 2753, 3233) returns 2746, and pow(2746, 17, 3233) returns 123.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-nums

15. Two strangers, one bank: which jobs are missing?

Missing information

Your browser has never talked to chase.com before. It wants to send a password.

Discussion prompt

Which of the three public-key jobs does the browser actually need here, and why is the private-message job alone not enough?

Hint: Encrypting to the wrong key is perfectly secure and completely useless.

Answer:

It needs key agreement, so that both sides end up with an AES key nobody else has, and it needs a signature from the bank, so that the other end is provably the bank. That is jobs 3 and 2.

Locking a message to a public key is useless if the public key came from an impostor: the message is then perfectly secret, and delivered to the attacker. Identity has to be proven, not assumed.

Security I, Lecture 3: TLS and the Web PKI slide s-recap-nums

16. Part 2 — The Internet before TLS

Section

Your messages cross machines you do not control

17. TLS is everywhere, and you use it all day

Concept

TLS gives two programs a private, authenticated channel over a network the attacker controls. Three places you used it this week:

Figure (svg): Three tiles: the Web (github.com with a lock), messaging (WhatsApp Web), and APIs (a secret Bearer key in every request)

Email between servers, VPNs, card payments and software updates also run over TLS. If a connection is secure today, TLS is almost certainly underneath.

Security I, Lecture 3: TLS and the Web PKI slide s-roadmap

18. What would leak if your API key went over plain HTTP?

Real world

Your script sends a request with Authorization: Bearer sk-proj-... to an API, from a laptop on the campus Wi-Fi.

Discussion prompt

If that request were plain HTTP, who could read the key, and what could they do with it? What does TLS change?

Hint: List every machine between the laptop and the API server.

Answer:

Every machine on the path: the Wi-Fi access point, the campus network, the ISPs and the backbone. Anyone who copies the key can make requests as you and bill your account until you revoke it, and nothing in the request tells you it was copied.

With TLS the header is inside the encrypted channel, so the path sees only scrambled bytes and the host name. TLS also checks that the server really is the API provider, so the key is not handed to an impostor. Both properties matter, and they are the subject of this series.

Security I, Lecture 3: TLS and the Web PKI slide s-roadmap

19. How a message travels across the Internet

Concept

Build it up from the two ends you care about: your laptop and the bank. Between them is a chain of machines, and none belongs to you or to the bank.

Figure (svg): Six boxes in a row: your laptop, cafe Wi-Fi, your ISP, the backbone, the bank's ISP, chase.com; the four middle machines belong to someone else

  1. The cafe Wi-Fi router: whoever runs it sees your traffic first
  2. Your ISP, the Internet Service Provider: the company you pay for access, such as Comcast, Verizon or your university
  3. The backbone: long-distance networks, big routers and undersea cables run by large carriers, tying the ISPs together
  4. The bank's own ISP at the other end

Your message is handed from one machine to the next, like a postcard going through the mail, and every hand that touches it can look at it.

Security I, Lecture 3: TLS and the Web PKI slide s-net-how

Security I, Lecture 3: TLS and the Web PKI slide s-div-bg

20. Put the path in order

Ranking

You open your banking site from a cafe. Order the machines your login passes through.

Put in order

  1. the cafe Wi-Fi router
  2. your ISP
  3. the backbone carriers
  4. the bank's ISP
  5. the bank's server

Why: Local first, then your provider, then the long-distance networks, then the provider on the far side, then the destination. Four of the five belong to neither you nor the bank, and on a plaintext network every one of them can read and change what passes.

Security I, Lecture 3: TLS and the Web PKI slide s-net-how

21. Without TLS, your login is a postcard

Concept

Make it concrete. Without encryption, a login is literally this text on the wire: the request line, the host, and the form with your password in plain characters.

POST /login HTTP/1.1
Host: www.chase.com
Content-Type: application/x-www-form-urlencoded

username=alice&password=hunter2
hopwhat it seesskill needed
cafe Wi-Fithe whole request, password includednone: any packet capture tool
your ISPthe whole requestnone
backbone carrierthe whole requestnone
the bank's ISPthe whole requestnone

Figure (svg): The same six-hop path, with every middle hop marked as reading the postcard

For the first years of the Web, logins, email and everything else travelled exactly like this.

Security I, Lecture 3: TLS and the Web PKI slide s-net-plaintext

22. How hard is it to read that postcard?

Prediction

Someone on the same open cafe Wi-Fi wants your plaintext password from the request on the last slide.

Predict first

What does it take?

  • Breaking an encryption scheme
  • Guessing the password offline
  • Nothing beyond capturing packets: the password is in the bytes
  • Physical access to your laptop

Correct: Nothing beyond capturing packets: the password is in the bytes

Why: There is nothing to break. The password is a run of ordinary characters in the request body, so any machine that forwards the packet, or listens on a shared network, simply has it. That is what plaintext means.

Security I, Lecture 3: TLS and the Web PKI slide s-net-plaintext

23. A machine in the middle can do three bad things

Concept

Three dangers, and they map exactly onto what TLS must guarantee.

Figure (svg): Three cards: READ (eavesdrop on the password), CHANGE (tamper: pay 10 becomes pay 9000), PRETEND (impersonate chase.com with a fake login page)

Read, change, pretend. Every network attack in this series is one of the three.

Security I, Lecture 3: TLS and the Web PKI slide s-net-threats

24. Read, change or pretend?

Sorting

Classify each incident by the danger it is.

Sort into buckets

Eavesdrop, tamper, or impersonate?

eavesdrop
A neighbour on open Wi-Fi copies your session cookie as it passes; An ISP logs every search query you send to a plaintext search engine
tamper
A hotel network injects advertising scripts into every page you load; A router rewrites the account number in a payment form
impersonate
A Wi-Fi hotspot named like the airport's serves a perfect copy of a bank login
read
Nothing is altered; data is copied as it passes.
change
The real server answered, but the bytes were modified in transit.
pretend
The party answering is not the one you meant to reach.

Security I, Lecture 3: TLS and the Web PKI slide s-net-threats

25. Story: a stranger at the coffee shop reads your account

Concept

A true story, from 2010. At any coffee shop, people used Facebook and Twitter over the shared Wi-Fi. The login page used encryption, but after logging in, the laptop talked to the site in plain HTTP, sending a session cookie with every request.

what happenedwhy it worked
a free browser add-on, Firesheep, listened on the shared Wi-Fithe session cookie crossed the network in plaintext
it listed everyone nearby who was logged ineach cookie identified one account
one click on a name opened that person's accountthe site treats whoever presents the cookie as the user

No skill was needed, which was the point its author wanted to make. Within months Facebook and Twitter offered encryption on every page, and soon after made it the default.

Security I, Lecture 3: TLS and the Web PKI slide s-story-eaves

Butler — Firesheep (ToorCon 12, October 2010) the original release post

26. The password was protected. Why was the account not?

Socratic

In the Firesheep story, the login form itself was sent over HTTPS. Only the pages after login were plain HTTP.

Discussion prompt

Why was protecting just the password not enough? What should have been protected, and what would a site do today to stop this?

Hint: What does the server check on every request after login?

Answer:

After login, the session cookie is as good as the password: the server lets in anyone who presents it. Protecting the login and then sending the cookie in plaintext just moves the secret the eavesdropper needs.

The fix is HTTPS on every page, plus marking session cookies Secure so the browser never sends them over plain HTTP. The general lesson: protect every message that carries a credential, not only the one where the user typed it.

Security I, Lecture 3: TLS and the Web PKI slide s-story-eaves

27. Story: a swapped program turns visitors into attackers

Concept

A true story about tampering, from 2015. Visitors all over the world loaded pages that pulled in a small analytics script from a popular Chinese search company, sent over plain HTTP.

what happenedwhy it worked
on its way through China's network, the script was swapped for a different oneplain HTTP has no integrity: any machine on the path can rewrite it
the new script made each browser keep requesting pages from GitHubthe browser runs whatever script arrives, with no way to tell it changed
millions of innocent browsers became a flood, and GitHub struggled for daysevery visitor became an unwitting attacker

Researchers named the system that did the swapping the Great Cannon. Nobody read anything secret: the program was simply changed on the way. Integrity matters even for content that is not secret.

Security I, Lecture 3: TLS and the Web PKI slide s-story-tamper

Marczak et al. — China's Great Cannon (Citizen Lab, April 2015) Citizen Lab's analysis of the March 2015 GitHub attack

28. Public content does not need encryption

Counterexample

A colleague says: our site serves only public pages and public JavaScript, nothing secret, so plain HTTP is fine.

Discussion prompt

Give a counterexample from this lecture, and say which of the three guarantees the colleague forgot.

Hint: Which story involved no secrets at all?

Answer:

The Great Cannon: the swapped script was public, yet changing it in transit turned every visitor's browser into a weapon. Hotel and ISP ad injection is a gentler version of the same thing.

The colleague is thinking only about confidentiality. Integrity, knowing the bytes arrived exactly as the server sent them, matters for every page, and especially for code the browser will run. That is one reason browsers now treat all plain-HTTP pages as not secure.

Security I, Lecture 3: TLS and the Web PKI slide s-story-tamper

29. Story: the free airport Wi-Fi that was not the airport's

Concept

The third danger, as something that could happen to you next month. Any laptop can create a Wi-Fi network with any name, so Free Airport WiFi might be a stranger at the next gate.

stepwhat you seewhat is really happening
join the networkFree Airport WiFithe stranger's laptop is now your router
open the bank's sitea page that looks exactly rightthe stranger's copy of the login page
type your passwordyou are passed on to the real bankthe stranger keeps the password and relays you

You never notice anything. What was missing is a way for your browser to check who really answered.

Security I, Lecture 3: TLS and the Web PKI slide s-story-imp

30. Would encryption alone have saved you?

Missing information

Suppose the fake airport hotspot's copy of the bank page used perfect encryption between your laptop and the stranger.

Discussion prompt

Is your password safe? What extra piece of information does your browser need, and where could it come from?

Hint: Who is at the other end of the encrypted connection?

Answer:

No. The encryption is perfect, and it delivers your password safely to the stranger, because the stranger is the other end of the encrypted channel. Encryption protects a conversation; it says nothing about who you are talking to.

The browser needs proof that the key at the other end belongs to the real bank: a signature from someone the browser already trusts, binding the bank's name to the bank's key. That is the certificate, and it is the central topic of TLS Lecture 3.

Security I, Lecture 3: TLS and the Web PKI slide s-story-imp

31. Why TLS was invented: you cannot shop with postcards

Concept

The Web took off in the early 1990s and people wanted to buy things, which meant typing a credit-card number. On the plaintext Web that number travelled like a postcard.

the postcard problemthe envelope propertythe guarantee
anyone on the path can read itsealedconfidentiality
anyone on the path can change ittamper-evidentintegrity
anyone can claim to be the shopsigned by the senderauthentication

Netscape designed SSL, the Secure Sockets Layer, in 1994 to put the postcard inside a sealed, signed envelope. In 1999 the standards body renamed it TLS, Transport Layer Security. Same idea, renamed and improved.

Security I, Lecture 3: TLS and the Web PKI slide s-why-tls

32. Which envelope property stops which story?

Matching

Match each story to the guarantee that would have stopped it.

Match the pairs

  • fs. Firesheep copying session cookies
  • gc. the Great Cannon swapping a script
  • ap. the fake airport hotspot's login page
  • conf. confidentiality: sealed
  • int. integrity: tamper-evident
  • auth. authentication: signed by the real sender

Why: Firesheep only read; sealing the cookie stops it. The Great Cannon only changed bytes; integrity rejects the altered script. The hotspot answered as the bank; only checking who signed defeats it. TLS has to give all three at once.

Security I, Lecture 3: TLS and the Web PKI slide s-why-tls

33. Part 3 — What TLS promises

Section

Pin down the enemy before any mechanism

34. The threat model: the attacker owns the network

Concept

Before any mechanism, say exactly who the enemy is. Setup: the attacker controls every machine between you and the bank.

the attacker CANthe attacker CANNOT (assumed)
read every packetbreak good cryptography: invert AES without the key, factor a 2048-bit modulus
change packets in flightreach into the bank's servers and steal its private key
drop or inject packetsrun code on your laptop
answer your DNS lookups with any address it likesmake you click through a browser warning (that is a user problem, covered in Lecture 3)

What it wants: your password and session cookie, to redirect your money, to pass itself off as the bank, and to do it all without you noticing. The right-hand column is a list of assumptions. If one fails, for example malware on your laptop, TLS cannot help you.

So the attacker cannot break the math directly. Every attack in this series wins through a weakness in the protocol or in the system around the math.

Security I, Lecture 3: TLS and the Web PKI slide s-what

Security I, Lecture 3: TLS and the Web PKI slide s-div-what

35. Inside the threat model, or outside it?

Discrimination

TLS promises protection only against the attacker it was designed for.

Sort into buckets

Is each attacker inside the TLS threat model (TLS must stop it) or outside it (TLS cannot help)?

inside: TLS must stop it
A rogue Wi-Fi router that rewrites packets; A DNS server that answers with the attacker's address; An ISP that records every byte for years
outside: TLS cannot help
Malware on your laptop that reads the browser's memory; An insider at the bank who copies the server's private key
in
Anything on the network, including DNS and long-term recording, is exactly the attacker TLS is built for.
out
Code on an endpoint or a stolen private key breaks the assumptions TLS rests on; other defences have to handle them.

Security I, Lecture 3: TLS and the Web PKI slide s-what

36. TLS answers each danger with one guarantee

Concept

Each danger gets exactly one guarantee.

Figure (svg): Eavesdrop maps to confidentiality, tamper to integrity, both provided by AEAD; impersonate maps to authentication, marked as the hard part

The first two come from authenticated encryption, which the cryptography lecture already built. The third, knowing who is really at the other end, is the hard part, and most of the TLS series is about it.

Security I, Lecture 3: TLS and the Web PKI slide s-guarantees

37. Which guarantee can AES-GCM not give you?

Elimination

AES-GCM is authenticated encryption: it encrypts and attaches a tag. Rule out what it does provide.

Eliminate the wrong options

Even with a perfect, shared AES-GCM key, which guarantee is still missing?

  • c. Confidentiality of the bytes
  • i. Integrity of the bytes
  • a. Knowing who holds the other copy of the key

Survives elimination: a

Why: A shared key proves only that the other end holds the same key. If you agreed on that key with an impostor, AES-GCM protects your conversation with the impostor perfectly. Authentication of the peer has to come from public-key crypto plus a trusted vouching party.

Security I, Lecture 3: TLS and the Web PKI slide s-guarantees

38. TLS is two steps: meet carefully once, then talk fast

Concept

An analogy for the structure. Meeting a stranger for private business, you first check each other's ID and quietly agree on a code word. That is careful and slow, so you do it once. Then you talk in the code for the rest of the meeting.

Figure (svg): Step 1, the handshake: identity and a key, with slow public-key crypto, once per connection; step 2, the record layer: AEAD on every byte at gigabytes per second

TLS is the same: the handshake uses public-key crypto to authenticate and agree on keys, then the record layer uses fast symmetric authenticated encryption for everything else. Two steps, because the two jobs need two different tools. TLS Lecture 2 builds both.

Security I, Lecture 3: TLS and the Web PKI slide s-two-protocols

39. Why not do everything with public-key crypto?

Hypothesis

Public-key crypto alone could, in principle, encrypt every record.

Predict first

What is the main reason TLS switches to symmetric encryption after the handshake?

  • Public-key operations are hundreds to thousands of times slower, and the data can be gigabytes
  • Public-key encryption is less secure than AES
  • Public keys can only be used once
  • Browsers do not support public-key encryption

Correct: Public-key operations are hundreds to thousands of times slower, and the data can be gigabytes

Why: A 2048-bit RSA private-key operation takes on the order of a millisecond; AES-GCM with hardware support moves gigabytes per second. So public key does the one-time job only it can do, meeting a stranger, and hands a key to AES for the bulk work.

Security I, Lecture 3: TLS and the Web PKI slide s-two-protocols

40. The TLS design recipe

Pattern

Every design decision in the series follows from four lines, in this order.

  1. Name the attacker: it owns the network, but cannot break the math or reach the endpoints
  2. Name the dangers: read, change, pretend
  3. Give one guarantee per danger: confidentiality, integrity, authentication
  4. Pick one tool per job: public key once to meet and authenticate, then authenticated symmetric encryption for the data

When you meet a protocol flaw, ask which line it violated. The whole history that follows is a list of answers.

41. Part 4 — 25 years of breaking SSL

Section

Every version exists because the one before it broke

42. The whole story on one line

Concept

A short history, because it explains why TLS 1.3 looks the way it does.

Figure (svg): A timeline: SSL 1.0 (1994, never shipped), SSL 2.0 (1995, short keys), SSL 3.0 (1996, POODLE 2014), TLS 1.0 (1999, BEAST 2011), TLS 1.1 (2006, retired), TLS 1.2 (2008, FREAK and Logjam), TLS 1.3 (2018, current)

Six of the seven versions were broken or abandoned. TLS 1.2 is still widely used and still allowed, but was hit by FREAK and Logjam through old options it kept accepting. TLS 1.3, standardised in 2018 as RFC 8446, is current. The next slides take them one at a time, each as a design flaw and the fix it led to.

Security I, Lecture 3: TLS and the Web PKI slide s-history

Security I, Lecture 3: TLS and the Web PKI slide s-div-hist

RFC 8996 — Deprecating TLS 1.0 and TLS 1.1 (March 2021) TLS 1.0 and 1.1 formally deprecated, 2021

43. Which versions should a server accept today?

Prediction

The IETF has formally prohibited or deprecated versions one at a time: SSL 2.0 in 2011, SSL 3.0 in 2015, TLS 1.0 and 1.1 in 2021.

Predict first

Which versions should a public server accept in 2026?

  • All of them, so no client is ever turned away
  • TLS 1.0 and newer
  • TLS 1.2 and TLS 1.3
  • Only SSL 3.0, since it is the most widely tested

Correct: TLS 1.2 and TLS 1.3

Why: RFC 6176, RFC 7568 and RFC 8996 removed SSL 2.0, SSL 3.0, TLS 1.0 and TLS 1.1. TLS 1.2, configured with modern AEAD cipher suites, and TLS 1.3 remain. Mozilla's modern profile goes further and accepts only TLS 1.3. Accepting everything is exactly the habit that the rest of this part shows to be dangerous.

Security I, Lecture 3: TLS and the Web PKI slide s-history

44. SSL 1.0 (1994): encryption without integrity

Concept

SSL 1.0 never shipped, and the reason is something you already know. It encrypted with RC4, a stream cipher designed by Ron Rivest in 1987: think of it as a one-time pad whose pad is generated from a short key, like CTR mode. It was the most used cipher on the Web for years, until RFC 7465 banned it from TLS in 2015.

Figure (svg): Plaintext pay 100 XOR an unknown keystream gives ciphertext; flipping a ciphertext bit flips the same plaintext bit; the CRC check has no key and can be recomputed by anyone

design choicewhy it fails
stream cipher: ciphertext = plaintext XOR keystreama flipped ciphertext bit flips the same plaintext bit, so an edit lands exactly where the attacker wants
CRC checksum instead of a MACa CRC has no key, so whoever edits the message recomputes it
no sequence numbersan old record could be replayed and would look fresh

Netscape's reviewers caught this, and SSL 1.0 was scrapped before release.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl1

45. Why a keyless checksum protects nothing

Worked example

A checksum detects accidents, such as a flipped bit on a noisy line. To detect people, the check must need a secret the attacker lacks. See it with CRC-32, the family SSL 1.0 relied on.

import zlib
zlib.crc32(b"pay Bob 100")   # 0xbb3640bd
zlib.crc32(b"pay Bob 900")   # 0xb5251105
# no key anywhere: whoever edits the message
# recomputes the checksum in one call
messageCRC-32who can compute it
pay Bob 1000xbb3640bdanyone
pay Bob 9000xb5251105anyone
HMAC-SHA256 of either messagedepends on the keyonly key holders

Figure (svg): The SSL 1.0 picture again: an edit to the ciphertext plus a recomputed CRC passes the check

Read the table as the attacker

Why: The attacker changes the message and then simply computes the new CRC, as the second row shows. The receiver's check passes, because the check was never secret.

Verify: in Python

Why: zlib.crc32(b"pay Bob 100") returns 0xbb3640bd and zlib.crc32(b"pay Bob 900") returns 0xb5251105: two valid checksums, no key used. Replace the CRC with HMAC under a secret key and the second value can no longer be produced by an outsider.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl1

46. SSL 2.0 (1995): the keys were too short

Concept

SSL 2.0 shipped in 1995 with RC4 and DES; AES did not exist until 2001. Its root cause was short keys.

Figure (svg): Bars: 40-bit export keys take about 18 minutes at a billion keys per second, 56-bit DES about 2.3 years, 128-bit AES about 10 to the 22 years

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl2

RFC 6176 — Prohibiting Secure Sockets Layer (SSL) Version 2.0 SSL 2.0 prohibited, 2011

47. How long does a 40-bit key last?

Estimation

A 40-bit key space has 2 to the 40, about 1.1 trillion, keys. Assume one machine tries a billion keys per second, which is modest today.

Predict first

Roughly how long to try every key?

  • About 18 seconds
  • About 18 minutes
  • About 18 days
  • About 18 years

Correct: About 18 minutes

Why: 1.1 trillion divided by a billion is about 1,100 seconds, a little over 18 minutes, and on average the key turns up halfway. In 1995 it took days on a university's machines, which was already too little. Each extra bit doubles the work, so 128 bits is out of reach for any computer that could ever be built.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl2

48. SSL 2.0, continued: nothing protected the menu

Concept

The client sends a menu of ciphers it supports; the server picks one. In SSL 2.0 nothing checked afterwards that both sides had seen the same menu.

Figure (svg): The client offers RC4-128, DES-56 and RC4-40; an attacker on the path deletes the first two; the server sees only RC4-40 and picks it

So an attacker on the path could delete the strong options and leave only the 40-bit one. Both sides were honest and both were fooled, and the attacker then had to break only a 40-bit key. This is the first downgrade attack, and the shape returns again and again. The fix, in SSL 3.0 and every version since, is a final handshake message that authenticates everything both sides said.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl2

49. SSL 3.0 (1996): the padding was never checked

Concept

SSL 3.0 lasted almost twenty years. It used MAC-then-encrypt with CBC mode, and the root cause of its death was one gap: the MAC covered the data but not the padding, and the padding bytes were never checked.

Figure (svg): An SSL 3.0 record: data and MAC covered by the MAC, padding covered by nothing, all of it CBC-encrypted

Bytes that nothing authenticates can be tampered with, and the server's reaction, accept or reject, then tells the attacker something about the plaintext. A server that reveals, one yes or no at a time, whether a tampered record was acceptable is called an oracle. Enough answers leak secrets such as a cookie.

POODLE, published by Google researchers in 2014, did exactly this to SSL 3.0, and browsers switched SSL 3.0 off for good. RFC 7568 prohibited it in 2015. The design lessons: authenticate every byte you decrypt, and use authenticated encryption so there is no separate padding step to get wrong.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl3

Möller, Duong, Kotowicz — This POODLE Bites: Exploiting the SSL 3.0 Fallback (Google, 2014) the original POODLE advisory

RFC 7568 — Deprecating Secure Sockets Layer Version 3.0 SSL 3.0 prohibited

50. Why is a yes-or-no answer dangerous?

Socratic

A server decrypts a record, finds the padding malformed and replies with a specific error; for good padding but a bad MAC it replies with a different one, or takes a different time.

Discussion prompt

Each reply is only one bit. Why is a server that answers this question repeatedly a security problem, and what are two design changes that remove the question entirely?

Hint: Who chooses the questions, and how many can they ask?

Answer:

Because the attacker chooses what to ask. Each tampered record is a question about the plaintext, and many one-bit answers add up to whole bytes of a secret. Security has to assume the attacker can ask as often as it likes.

Fix one: authenticate the entire ciphertext before doing anything else with it, Encrypt-then-MAC, so a tampered record is rejected before padding is ever looked at. Fix two: use an AEAD mode such as AES-GCM, which has no padding at all. TLS 1.3 does the second, and also sends the same alert for every failure.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-ssl3

51. TLS 1.0 (1999): the next IV was already public

Concept

TLS 1.0's root cause was a predictable IV. CBC mode is secure only if each IV is unpredictable to the attacker before the plaintext is chosen. TLS 1.0 used the last ciphertext block of the previous record as the next record's IV, and that block had already crossed the wire.

requirement from the CPA lecturewhat TLS 1.0 didconsequence
IV unpredictable before encryptionIV = last ciphertext block already sentthe attacker knows the next IV in advance
same plaintext never recognisablechosen-plaintext guesses become testablesecrets can be confirmed one guess at a time
fresh randomness per recordnonefails the CPA game outright

Think of a lock whose next combination is printed on the last receipt. BEAST, in 2011, showed that a script in the victim's browser could use this to recover cookies. The fixes: TLS 1.1 gave every record a fresh random IV, browsers patched TLS 1.0 by splitting records, and TLS 1.3 removed CBC altogether.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls10

RFC 7457 — Summarizing Known Attacks on TLS and DTLS (BEAST, POODLE and others) section 2.4, BEAST

52. Two truths and a myth about IVs

Two truths and a lie

Two of these statements are true and one is a myth.

Eliminate the wrong options

Which statement is the myth?

  • t1. An IV must be secret, which is why TLS 1.0 failed: it sent the IV in the clear
  • t2. A CBC IV may be public, but it must be unpredictable before the plaintext is chosen
  • t3. TLS 1.1 fixed the problem by sending a fresh random IV with every record

Survives elimination: t1

Why: IVs are not secret: CBC sends them in the clear all the time. What matters is that the attacker cannot know the IV before choosing what to get encrypted. TLS 1.0's chained IV was public before the next encryption, and that predictability, not visibility, was the flaw.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls10

53. TLS 1.1 and 1.2: good fixes, dragged down by old options

Concept

TLS 1.1 (2006) fixed the IV with a fresh random one per record. TLS 1.2 (2008) added AES-GCM, encryption and MAC in one step, which ends padding problems. The protocol was finally good. The problem was compatibility.

attackyearold option still acceptedwhat the attacker didfix
FREAK2015export-grade RSA, 512-bit modulustricked connections into it, then factored the 512-bit nremove export suites; patch the client bug
Logjam2015export-grade Diffie-Hellman, 512-bit primethe same idea against 512-bit Diffie-Hellman2048-bit or elliptic-curve groups only
POODLE fallback2014SSL 3.0 after a failed connectionmade the newer handshake fail so clients retried on SSL 3.0disable SSL 3.0; signal fallback

Remember the chain from why RSA is secure: factor n, get p and q, get phi, get d, read the traffic. FREAK did the factoring step for real: a 512-bit modulus fell in about seven hours for roughly a hundred dollars of rented cloud machines.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls12

Beurdouche et al. — A Messy State of the Union: Taming the Composite State Machines of TLS (IEEE Security and Privacy 2015; FREAK) FREAK

Adrian et al. — Imperfect Forward Secrecy: How Diffie-Hellman Fails in Practice (CCS 2015; Logjam) Logjam and weakdh.org

54. Is factoring a 512-bit RSA key a big project?

Commit first

In 2015 the FREAK researchers needed to factor a 512-bit RSA export key quickly enough to matter.

Predict first

What did it cost them, roughly? Bet your confidence.

  • Months on a national lab's supercomputer
  • About seven hours and a hundred dollars of rented cloud machines
  • It is impossible; 512-bit RSA has never been factored
  • A few seconds on a phone

Correct: About seven hours and a hundred dollars of rented cloud machines

Why: 512-bit RSA was first factored publicly in 1999, and by 2015 the open-source CADO-NFS tool on rented machines did it in hours. Export-grade crypto was designed in the 1990s to be breakable by governments; twenty years later it was breakable by anyone with a credit card. Key sizes must anticipate the future, not the present.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls12

55. The pattern: compatibility kept the broken versions alive

Concept

Step back and the history is a loop.

Figure (svg): A loop: a version ships, someone breaks it, a new version fixes it, servers keep the old one for old clients, and in the middle a downgrade forces both sides back

  1. A version ships; someone breaks it; a newer version fixes it
  2. The world does not upgrade overnight, so servers keep speaking the old version for old clients
  3. That is the opening: an attacker forces both sides back onto the broken version, a downgrade

SSL 2.0 cipher stripping, POODLE fallback, FREAK and Logjam are all this loop. TLS 1.3 breaks it: its designers deleted the weak options instead of keeping them around. Old clients that cannot speak 1.3 still use 1.2, but 1.3 itself carries none of the old baggage.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-pattern

56. Trap: leaving old versions on is harmless

Trap

The trap

A common belief: modern browsers always pick TLS 1.3, so leaving SSL 3.0, TLS 1.0 and export ciphers enabled only helps old clients and cannot hurt new ones.

the beliefwhat actually happened
new clients pick the best versionan attacker can make the best version fail, or edit the menu, so the old one is chosen
weak suites are never usedFREAK and Logjam forced exactly those suites on modern clients
only old clients are at riskPOODLE reached modern browsers through their fallback retry

The fix

A connection is only as strong as the weakest option both ends will accept, because the attacker gets to influence the choice. The fix has two halves: remove weak options from servers and clients, and authenticate the negotiation itself, so any tampering with the menu is detected. TLS 1.3 does both; the next lecture shows how its handshake signs the negotiation.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-pattern

RFC 8446 — The Transport Layer Security (TLS) Protocol Version 1.3 appendix D.4, downgrade protection

57. Each version, its flaw and its fix

Comparison

Fill in the missing cells of the summary.

Comparison matrix

versionroot flawattack or eventfix
SSL 1.0no keyed integrity (CRC, not a MAC)caught in reviewnever shipped
SSL 2.040-bit keys, unprotected menuexport brute force, cipher strippingauthenticate the handshake (SSL 3.0)
SSL 3.0padding outside the MACPOODLE (2014)prohibited, RFC 7568
TLS 1.0predictable chained IVBEAST (2011)random IV per record (TLS 1.1)
TLS 1.2still accepts export optionsFREAK, Logjam (2015)delete weak options (TLS 1.3)

Notice that no row says the cipher was broken by mathematics alone. Every failure is a design or configuration choice around the cryptography.

Security I, Lecture 3: TLS and the Web PKI slide s-history

58. Match the attack to its root cause

Matching

Each historical attack exploited one design flaw.

Match the pairs

  • poodle. POODLE
  • beast. BEAST
  • freak. FREAK
  • logjam. Logjam
  • pad. padding bytes not covered by the MAC
  • iv. an IV known before encryption
  • rsa. a 512-bit export RSA modulus
  • dh. a 512-bit export Diffie-Hellman prime

Why: POODLE used SSL 3.0's unchecked padding, BEAST used TLS 1.0's chained IV, and FREAK and Logjam forced export-size RSA and Diffie-Hellman that could be broken in hours. Two are bad modes of use, two are leftover key sizes, and none is a break of the underlying cipher.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls12

59. Part 5 — Breaking the loop on your own server

Section

Refuse the old versions, then prove it

60. Configure a server to refuse the broken versions

Worked example

The defensive half of the history is two lines of configuration and two commands to check them. Here is the shape for nginx, following Mozilla's intermediate profile.

# nginx: accept only the two versions still allowed
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers   ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers off;

# check from a client: these must fail
#   openssl s_client -tls1   -connect example.com:443
#   openssl s_client -tls1_1 -connect example.com:443
linewhat it doeswhich history it ends
ssl_protocols TLSv1.2 TLSv1.3refuses SSL 2.0, SSL 3.0, TLS 1.0 and 1.1stripping, POODLE fallback, BEAST
ssl_ciphers ECDHE ... GCM, CHACHA20only forward-secret key exchange and AEAD ciphersexport RSA and DH (FREAK, Logjam), RC4, CBC padding
ssl_prefer_server_ciphers offlets the client pick among strong suitesnothing weak is left to pick
the two openssl commandstry to connect with TLS 1.0 and 1.1proves the refusal from outside

Figure (svg): Probe results for chase.com: TLS 1.0 and 1.1 get alert 70 protocol_version; TLS 1.2 negotiates ECDHE-RSA-AES256-GCM-SHA384; TLS 1.3 negotiates TLS_AES_256_GCM_SHA384

Read a real server's answer

Why: Probing chase.com in October 2026: openssl s_client -tls1 and -tls1_1 were refused with TLS alert 70, protocol_version, while -tls1_2 negotiated ECDHE-RSA-AES256-GCM-SHA384 and -tls1_3 negotiated TLS_AES_256_GCM_SHA384.

Verify: from the outside

Why: A correctly hardened server shows exactly that pattern: the old versions fail with protocol_version, and both allowed versions negotiate an ECDHE key exchange with an AEAD cipher. If -tls1 succeeds, the configuration did not take effect.

Mozilla — Server Side TLS recommended configurations intermediate configuration

RFC 8996 — Deprecating TLS 1.0 and TLS 1.1 (March 2021) section 1, why TLS 1.0 and 1.1 are deprecated

61. Code review: what is wrong with this TLS configuration?

Error analysis

A teammate added this to a server, so that no customer is ever turned away. Open each note.

Annotate

  • SSLv3 is prohibited by RFC 7568: its padding is not covered by the MAC (POODLE). TLSv1 and TLSv1.1 are deprecated by RFC 8996 (BEAST, SHA-1 and MD5 in the handshake).
  • EXPORT re-enables the 40-bit and 512-bit suites that FREAK and Logjam forced connections into.
  • RC4 has been banned from TLS since RFC 7465; its keystream biases leak plaintext. 3DES has a 64-bit block, which is too small for long connections.
  • The comment is the root cause: keeping weak options just in case is exactly the compatibility loop an attacker exploits. Replace with ssl_protocols TLSv1.2 TLSv1.3 and an ECDHE plus AEAD cipher list.

Every item on this list once had a name and a press release. Configuration is where most of the history is either repeated or avoided.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-pattern

62. Check a server you depend on

Real world

You can repeat the chase.com probe on any public HTTPS server, including one you run.

Discussion prompt

Which commands would you run, what output means the server is hardened, and which free tool gives a full report without a terminal?

Hint: One command per version.

Answer:

Run openssl s_client -tls1 -connect host:443 and the same with -tls1_1: a hardened server answers with an alert such as protocol_version. Then -tls1_2 and -tls1_3 should connect and print an ECDHE key exchange and a GCM or CHACHA20-POLY1305 cipher. Your own OpenSSL may refuse old versions before sending anything; that is your client's policy, not the server's answer.

Qualys SSL Labs' public server test grades versions, cipher suites and known weaknesses in one report. Only test servers you own or are allowed to test; these probes are ordinary handshakes, but scanning other people's systems at scale is not.

Security I, Lecture 3: TLS and the Web PKI slide s-hist-tls12

63. Checkpoint: name the flaw

Check

Solve it on paper before you click.

Check your understanding

A design encrypts each message with a stream cipher and appends a CRC-32 of the plaintext, also encrypted. What is the most serious problem?

  • A. CRC-32 is too slow for network use
  • B. An attacker can change the message and fix the checksum, because the integrity check uses no key (correct)
  • C. Stream ciphers cannot encrypt messages of arbitrary length
  • D. The CRC reveals the plaintext

Answer: B

Why: This is SSL 1.0. Flipping ciphertext bits flips the same plaintext bits, and a CRC is linear and keyless, so the change to the checksum is predictable too. Detecting a person, not noise, needs a MAC under a secret key, or an AEAD mode.

Why A tempts people
CRC-32 is extremely fast; speed is not the issue.
Why C tempts people
Stream ciphers handle any length; that is one of their advantages.
Why D tempts people
The CRC is encrypted and is a 32-bit summary; the danger is forgery, not disclosure.

64. Checkpoint: the threat model

Check

Solve it on paper before you click.

Check your understanding

Which event would TLS, working exactly as designed, fail to protect you against?

  • A. A coffee-shop router reading every packet
  • B. A DNS server sending you to the attacker's machine
  • C. A browser extension you installed that reads every page you open (correct)
  • D. An ISP recording your traffic to read it later

Answer: C

Why: Code running on your own machine sits at an endpoint, outside the threat model: it sees the page after TLS has decrypted it. The other three are network attackers, exactly the adversary TLS is built to defeat.

Why A tempts people
Reading packets is eavesdropping; TLS encryption defeats it.
Why B tempts people
Redirection is impersonation; certificate checking defeats it, because the attacker cannot prove it is the real site.
Why D tempts people
Recording is eavesdropping over time; TLS 1.3's forward secrecy keeps even a later key theft from unlocking it.

65. Draw the case for TLS

Connect it up

Put the whole lecture on one page.

Draw it

Draw the six-hop path from laptop to bank. Mark where each of the three stories happened (Firesheep, the Great Cannon, the fake hotspot) and label each with read, change or pretend. Next to it, draw the three guarantees and the tool for each. Then draw the version timeline and, for each retired version, write the one guarantee or rule it violated.

A good map makes every historical break land on one guarantee or one rule of the design recipe, and shows that authentication of the other end is the only guarantee the cryptography lecture did not already supply.

66. Exit ticket

Exit ticket

One question to check the central idea of the history.

Predict first

Why did so many attacks succeed against connections between two modern, up-to-date endpoints?

  • Because AES and RSA were broken mathematically
  • Because both endpoints still accepted weak options, and the attacker could steer the negotiation towards them
  • Because modern endpoints use shorter keys than old ones
  • Because TLS never encrypts the handshake

Correct: Because both endpoints still accepted weak options, and the attacker could steer the negotiation towards them

Why: Downgrades work whenever strong endpoints keep speaking weak protocols and the negotiation is not authenticated. The cure is to delete the weak options and to authenticate everything both sides said during the handshake, which is what TLS 1.3 does.

67. What you can do now

Recap

The thread: the network belongs to someone else, so a secure channel must give confidentiality, integrity and authentication; the first two come from authenticated encryption, the third is the hard part; and every old version failed on a design choice around the cryptography, kept alive by compatibility.

versionstatus in 2026
SSL 2.0, SSL 3.0prohibited (RFC 6176, RFC 7568)
TLS 1.0, TLS 1.1deprecated (RFC 8996)
TLS 1.2allowed, with ECDHE and AEAD suites only
TLS 1.3current (RFC 8446); next lecture

Next: TLS Lecture 2 builds the TLS 1.3 handshake message by message, with Diffie-Hellman on real numbers, and shows how it signs the negotiation so a downgrade is caught.

Security I, Lecture 3: TLS and the Web PKI slide s-ack — Lecture materials by Suman Jana (Columbia University), with slides originally from Vitaly Shmatikov; re-typeset and extended in the Security I course

RFC 8446 — The Transport Layer Security (TLS) Protocol Version 1.3 the TLS 1.3 standard

Sources

  1. Security I, Lecture 3: TLS and the Web PKI
  2. RFC 8446 — The Transport Layer Security (TLS) Protocol Version 1.3
  3. RFC 6101 — The Secure Sockets Layer (SSL) Protocol Version 3.0 (historic)
  4. RFC 6176 — Prohibiting Secure Sockets Layer (SSL) Version 2.0
  5. RFC 7568 — Deprecating Secure Sockets Layer Version 3.0
  6. RFC 8996 — Deprecating TLS 1.0 and TLS 1.1 (March 2021)
  7. RFC 7465 — Prohibiting RC4 Cipher Suites
  8. Möller, Duong, Kotowicz — This POODLE Bites: Exploiting the SSL 3.0 Fallback (Google, 2014)
  9. Beurdouche et al. — A Messy State of the Union: Taming the Composite State Machines of TLS (IEEE Security and Privacy 2015; FREAK)
  10. Adrian et al. — Imperfect Forward Secrecy: How Diffie-Hellman Fails in Practice (CCS 2015; Logjam)
  11. Butler — Firesheep (ToorCon 12, October 2010)
  12. Marczak et al. — China's Great Cannon (Citizen Lab, April 2015)
  13. RFC 7457 — Summarizing Known Attacks on TLS and DTLS (BEAST, POODLE and others)
  14. Mozilla — Server Side TLS recommended configurations

Want this taught 1-on-1? Alexander tutors Computer Security — $55/session, free consultation.

Book on Wyzant · Text (657) 465-8108