HTTP vs HTTPS: What the S Actually Buys You

HTTPS is HTTP inside a TLS tunnel, and the S buys three separate things: confidentiality, integrity, and authentication. The one nobody mentions, authentication, is the one that actually matters.

Tech Talk News Editorial10 min readUpdated Nov 18, 2026
#http#https#tls#web-security#encryption#networking
ShareXLinkedInRedditEmail
HTTP vs HTTPS: What the S Actually Buys You

Key takeaways

  • HTTPS is HTTP carried inside a TLS connection on port 443 instead of port 80, and TLS (RFC 8446) adds three separate properties that people blur into one word: confidentiality, integrity, and authentication.
  • Authentication is the half that makes the other two worth anything. Encryption without an identity check gives you a perfectly private, perfectly tamper-proof connection to a man in the middle.
  • The padlock proves the server controls the domain you typed and that the connection is protected, nothing more. A scammer who registers paypa1-secure.com can get a valid certificate for it, free and automatically.
  • Let's Encrypt left beta on April 12, 2016 with 1.7 million certificates issued. By December 2025 it was issuing about 10 million per day, and roughly 80% of page loads worldwide and close to 95% in the U.S. were over HTTPS, according to Firefox statistics.
  • Chrome 154, released in October 2026, turns on its Always Use Secure Connections setting by default, so users get a warning before the first visit to a public site without HTTPS.

HTTP vs HTTPS is a difference of one layer: HTTPS is ordinary HTTP carried inside a TLS (Transport Layer Security) connection. That layer adds three things plain HTTP has none of, which are encryption, tamper detection, and proof that the server really owns the domain you typed.

We taught a generation of internet users that the padlock means a site is safe. It doesn't.

It means the pipe is private and the server controls the name, and phishing sites get padlocks the same way everyone else does, for free and automatically. So here is what the S buys you, and why the part nobody mentions is the part that matters.

Summary

The S in HTTPS is TLS, and TLS gives you three distinct things people blur together: confidentiality (nobody on the wire can read your traffic), integrity (nobody can tamper with it undetected), and authentication (you're really talking to the site you think you are). HTTP uses port 80 and gives you none of the three. HTTPS uses port 443 and gives you all of them. The padlock is the lowest bar, not a trust signal.

HTTP sends everything in the clear

HTTP is plain text. When your browser asks an HTTP server for a page, it sends something that looks almost exactly like this, byte for byte, across every router, switch, and wifi access point between you and the server:

a plain HTTP request, on the wirehttp
GET /account/settings HTTP/1.1
Host: example.com
Cookie: session=8f3a9c1e7b2d4f60
Authorization: Basic YWxpY2U6aHVudGVyMg==
User-Agent: Mozilla/5.0
Every device on the path can read this. The session cookie and that base64 password are sitting right there in the open.

Anyone in the middle can read that. The coffee-shop wifi you're on. The ISP routing your packets. Some box in a data center three hops along the path. They see the cookie, the page you asked for, and the data that comes back.

And reading is the gentle version. The position on the wire that lets you read traffic lets you change it. An attacker can rewrite the response, inject a script, or swap a download link, invisibly, because HTTP has no way to tell a tampered response from a real one.

That base64 string in the example isn't encryption, by the way. It's an encoding. YWxpY2U6aHVudGVyMg== decodes straight back to alice:hunter2 with a one-liner anyone can run. People confuse encoding and encryption constantly, and HTTP is where that confusion gets expensive.

The S is TLS, and it does three jobs

HTTPS is HTTP running inside a TLS tunnel. The standard defines the HTTPS scheme as HTTP over a TLS-secured connection on TCP port 443 by default, and defines “secured” to mean the server has been authenticated as acting on behalf of the identified authority.[1]

TLS 1.3, published as RFC 8446 in August 2018, states its goal in one line: prevent eavesdropping, tampering, and message forgery.[2] Those are three separate properties.

  • Confidentiality. The traffic is encrypted, so the people in the middle see scrambled bytes instead of your cookie and your password. This is what everyone means when they say “HTTPS encrypts your data.”
  • Integrity. Every chunk of data carries a cryptographic check. If anything on the path flips a single bit, the check fails and your browser knows the data was tampered with. No more silent script injection.
  • Authentication. TLS proves the server is the one that owns the domain you typed. This is the half everyone forgets, and it makes the other two worth anything.

Plain HTTP

HTTPS (TLS)

  1. Confidentiality
    none
    encrypted
  2. Integrity
    none
    verified
  3. Authentication
    none
    cert-checked
Qualitative scale, not a measurement. HTTP gives you zero of the three. The row to watch is the last one: authentication is what stops an attacker from pretending to be the server.

Here's why authentication is the piece that makes the other two worth anything. Imagine you got encryption and integrity but skipped the identity check. You'd have a perfectly encrypted, perfectly tamper-proof connection to whoever managed to sit in the middle and answer first.

That's a man-in-the-middle attack, and encryption without identity does nothing to stop it. You'd be securely talking to the attacker. The whole point of the certificate is to slam that door shut.

HTTP and HTTPS side by side. Sources: RFC 9110, RFC 8446, RFC 6797.
PropertyHTTPHTTPS
URL schemehttp://https://
Default port80443
Who can read the trafficAnyone on the pathOnly the two endpoints
TamperingUndetectableDetected and rejected
Server identityUncheckedCertificate verified against trusted authorities
Needs a certificateNoYes, free from Let's Encrypt
Hides which site you visitNoPartly: hostname can still leak

The handshake takes one round trip in TLS 1.3

Before any page data moves, the browser and server run a short negotiation. TLS 1.3 trimmed it to a single round trip and removed the static key exchanges older versions allowed, so every public-key exchange now provides forward secrecy: stealing the server's long-term key later does not unlock traffic you recorded earlier.[2]

TLS 1.3 handshake

One round trip, then encrypted data

  1. Step 1Client to server

    Client sends ClientHello

    The browser lists the cipher suites it supports and includes its half of a key exchange, so the server can derive a shared secret immediately.

  2. Step 2Server to client

    Server answers in one flight

    ServerHello carries the server’s half of the key exchange. After that, encrypted: its Certificate, a CertificateVerify signature proving it holds the certificate’s private key, and Finished.

  3. Step 3Client to server

    Client verifies, then sends Finished

    The browser checks the certificate chain and the name, sends its own Finished message, and starts sending HTTP requests under the new keys.

Takeaway

The slow public-key math only builds the shared secret. The fast symmetric encryption it produces then carries your page. The certificate in step 2 is what turns that secret from private into private with the right party.

Source: RFC 8446, section 2. Message names are from the RFC. Over TCP, this round trip comes after the TCP handshake.

Over TCP, that is the TCP handshake first and the TLS handshake after, which is why the TCP and UDP difference shows up in page-load time.

HTTP/3 runs on QUIC, which carries the TLS 1.3 handshake inside its own, and RFC 9001 says that absent packet loss most new QUIC connections are established and secured within a single round trip.[3] This is also much of why a CDN speeds up a site: the saving is in round trips, not bytes.

Certificates prove a name, not an intention

Your browser gets a certificate claiming to be example.com. Why believe it? Because it is signed by a Certificate Authority, an organization whose job is to verify that whoever requested the certificate controls the domain.

Your browser and operating system ship with a built-in list of authorities they trust, and a certificate that chains up to one of them checks out.[4] You trust your browser's list, the list vouches for the authority, and the authority vouches for the domain.

What the padlock checks

The browser verifies a name and a chain, never a business

What the browser checks

  • Signed by a trusted authorityThe chain ends at a root your browser already trusts
  • Name matches the address barThe certificate was issued for the domain you typed
  • Server holds the private keyThe CertificateVerify signature in the handshake

Padlock shows

The connection is encrypted and the server controls this domain.

What you can conclude

  • Nobody on the path reads or edits it
  • You reached the real owner of this domain name
Never checkedWhether the people running the domain are honestA scam site on a valid certificate gets the same padlock.

Domain-validated certificates confirm control of a DNS name. Nothing else.

For years this was where the “HTTPS is expensive and annoying” excuse lived. Certificates cost money and you renewed them by hand. Then Let's Encrypt, a free, automated, nonprofit authority, left beta on April 12, 2016, having issued more than 1.7 million certificates.[5]

By December 2025 it was issuing about ten million a day, and it reported roughly 80% of page loads worldwide, and close to 95% in the U.S., were over HTTPS, based on Firefox statistics.[6]

The thing that moved the web was not a mandate. It was making the cost zero. I find that the most believable story in security: people do the secure thing when it is the easy thing.

1.7M
Certificates Let's Encrypt had issued when it left beta, April 2016
~10M/day
first 10M day: end of September 2025
Certificates Let's Encrypt issues on a typical day, late 2025
~80%
Firefox statistics
Share of page loads over HTTPS worldwide, December 2025
~95%
Firefox statistics
Share of page loads over HTTPS in the U.S., December 2025

Heads up

A certificate proves control of a domain. It does not prove the business behind it is honest. Domain-validated certificates, the free automated kind, confirm one thing: whoever got the certificate controls the DNS for that name. A scammer who registers paypa1-secure.com controls that domain and can get a valid padlock for it. The lock is real. The site is still a scam.

What HTTPS does not hide

This is where the padlock oversells itself. HTTPS protects the contents of your connection, but a few things leak anyway.

  • Which site you're visiting. The hostname leaks in two places. DNS, the lookup that turns example.com into an IP address (how DNS works), has historically been unencrypted. And SNI (Server Name Indication), the field in the TLS handshake that tells a shared server which site you want, is sent before encryption starts. So the network can often see that you visited example.com, even if it can't see what you did there. Encrypted Client Hello, published as RFC 9849 in March 2026, encrypts the server name inside the handshake. The RFC itself admits it does not fully hide the destination, because plaintext DNS queries and visible IP addresses can still give it away.[7]
  • Size and timing. An observer can see how much data moved and when. That metadata can be enough to fingerprint which page you loaded, without decrypting a single byte.
  • Whether the site is trustworthy. It bears repeating because it bites real people. HTTPS makes the pipe secure. It does not make the thing at the end of the pipe honest.
“The padlock means encrypted, not trustworthy. It tells you nobody is reading or tampering with the connection, and nothing about the intentions of the people running the domain.”

The cryptography behind that padlock has a deadline on it, because a sufficiently large quantum computer breaks the key exchange retroactively: the post-quantum migration.

The Secure cookie attribute that depends on all of this is one of three that decide whether a login survives contact with an attacker, which is the subject of JWTs versus sessions.

And when a secured site answers with an error instead of a page, the 503 and 401 status codes tell you which side broke.

Plain HTTP is effectively finished

For any real site in 2026, HTTP is no longer a choice you weigh. The ecosystem closed ranks around HTTPS, with carrots and sticks.

  • Browsers now warn first. Google announced in October 2025 that Chrome 154, released in October 2026, turns on its Always Use Secure Connections setting by default, so Chrome asks permission before the first visit to any public site without HTTPS. In Google's Chrome 141 experiment, the median user saw fewer than one such warning per week, and the 95th-percentile user fewer than three.[8] The median user barely meets the warning because the sites they use are already encrypted.
  • New protocols assume TLS. HTTP/3 runs on QUIC, and QUIC carries the TLS 1.3 handshake, so there is no unencrypted HTTP/3.[3] Browsers also gate features such as service workers to secure contexts, which do not work over plain HTTP (localhost excepted).[9]
  • HSTS (HTTP Strict Transport Security) lets a site tell browsers to only ever talk to it over HTTPS. The max-age directive says for how many seconds the browser should remember, and includeSubDomains extends the policy to every subdomain.[10]

An HSTS header is a single line, and it's the difference between “we support HTTPS” and “we refuse to do anything else”:

response headers worth settinghttp
HTTP/2 200
strict-transport-security: max-age=63072000; includeSubDomains; preload
content-type: text/html; charset=utf-8
Two years of forced HTTPS (63,072,000 seconds), applied to every subdomain, eligible for the browser preload list. The preload part closes the first-request gap a plain redirect leaves open.

If you're the one building the site

The practical checklist is short now, which is the whole point of how far this got. None of this is the day-long ordeal it was a decade ago.

  1. Get a certificate. It's free and automatic. Most hosts and platforms provision one for you on deploy. If you're running your own server, an ACME client (the automated certificate protocol Let's Encrypt uses) renews it on a schedule and you never think about it again.
  2. Redirect HTTP to HTTPS. Any request that arrives on port 80 gets a permanent redirect to the HTTPS version. Don't serve real content over plain HTTP at all.
  3. Set HSTS. Add the Strict-Transport-Security header once you're confident HTTPS works everywhere. It closes the gap on the first request, the one a plain redirect leaves exposed to a downgrade attack.

That's it. The cost dropped to zero, the tooling automated itself, and the only real work left is remembering to do it. Which makes it strange how much of the public still reads the padlock as a verdict on the site rather than a fact about the connection.

So here's the take I'd leave you with. The padlock is the lowest bar there is. It says the wire is private and the server owns the domain, nothing more.

Takeaway

Encryption gets all the credit. Authentication, the certificate check that proves you're talking to the real server and not someone wearing its face, is what actually saves you.

Sources and further reading

  1. 1.PrimaryIETF, RFC 9110, "HTTP Semantics," section 4.2. The https scheme defaults to TCP port 443 (HTTP over TLS); "secured" means the server has been authenticated as acting on behalf of the identified authority. The http scheme defaults to port 80.
  2. 2.PrimaryIETF, RFC 8446, "The Transport Layer Security (TLS) Protocol Version 1.3" (August 2018). Designed to prevent eavesdropping, tampering, and message forgery; handshake messages; all public-key key exchanges provide forward secrecy.
  3. 3.PrimaryIETF, RFC 9001, "Using TLS to Secure QUIC". QUIC carries the TLS 1.3 handshake; absent packet loss, most new connections can be established and secured within a single round trip.
  4. 4.ReportingCloudflare Learning Center, "What is a certificate authority?". Browsers and operating systems ship with a trusted root list; certificates chain to it.
  5. 5.PrimaryLet's Encrypt, "Leaving Beta, New Sponsors" (April 12, 2016). Let's Encrypt leaves beta; more than 1.7 million certificates issued as of April 10, 2016.
  6. 6.PrimaryLet's Encrypt, "10 Years of Let's Encrypt" (December 9, 2025). About ten million certificates on frequent days; roughly 80% of page loads worldwide and close to 95% in the U.S. over HTTPS, from Firefox statistics.
  7. 7.PrimaryIETF, RFC 9849, "TLS Encrypted Client Hello" (March 2026). Encrypts the ClientHello, protecting the server name; plaintext DNS queries and visible IP addresses can still reveal the destination.
  8. 8.PrimaryGoogle, "HTTPS by default" (October 28, 2025). Chrome 154, October 2026, enables Always Use Secure Connections by default; Chrome 141 experiment: median user under one warning per week, 95th percentile under three.
  9. 9.PrimaryMDN Web Docs, "Secure contexts". Many web APIs, including service workers, are available only in a secure context; localhost counts as one.
  10. 10.PrimaryIETF, RFC 6797, "HTTP Strict Transport Security (HSTS)" (November 2012). Defines the max-age and includeSubDomains directives of the Strict-Transport-Security header.

Frequently asked questions

What is the difference between HTTP and HTTPS?
HTTPS is HTTP running inside a TLS tunnel, and that tunnel adds three things plain HTTP has none of: confidentiality, integrity, and authentication. HTTP uses port 80 and sends everything as readable text, so any router or wifi access point on the path can read your session cookie and alter the response. HTTPS uses port 443, encrypts the bytes, detects tampering, and proves the server controls the domain.
Does the padlock icon mean a website is safe?
No. The padlock means the connection is encrypted and the server controls the domain you typed. It says nothing about whether the people running that domain are honest. Domain-validated certificates are free and automated, so phishing sites get padlocks too. The lock is real, and the site can still be a scam.
What happens during a TLS handshake?
In TLS 1.3 the client sends a ClientHello with its key share, and the server answers with its own key share, its certificate, a signature proving it holds the certificate key, and a Finished message. The client verifies the certificate, sends its own Finished message, and application data flows. That takes one round trip, and every key exchange now provides forward secrecy.
Is HTTPS slower than HTTP?
Slightly, on the first request, and almost never in a way you would notice. TLS 1.3 completes its handshake in one round trip after the TCP connection opens, and HTTP/3 over QUIC merges the transport and TLS handshakes so a new secure connection also takes about one round trip. The newer protocol versions are built on TLS, so the fastest paths on the web are all encrypted.
Does HTTPS hide which websites I visit?
Not fully. The hostname leaks in two places: plaintext DNS lookups and the Server Name Indication field in the TLS handshake. Traffic size and timing leak too. Encrypted Client Hello, RFC 9849, encrypts the server name inside the handshake, but the RFC itself notes plaintext DNS queries and visible IP addresses can still reveal the destination.
Should every website use HTTPS, even with no login or payment?
Yes. Without HTTPS anyone on the path can inject scripts or swap downloads in your pages, and browsers restrict features like service workers to secure contexts. Chrome 154, released in October 2026, also warns users before their first visit to a public site that lacks HTTPS. Certificates are free through Let's Encrypt and most hosts provision them automatically.

Written by

Tech Talk News Editorial

Computer engineering background. Writes about software, AI, markets, and real estate, and the places where the three meet.

More about the author
ShareXLinkedInRedditEmail