CS Fundamentals Trainer · Guias

TLS e HTTPS

Como os handshakes do TLS 1.3 e 1.2 funcionam mensagem por mensagem, por que o forward secrecy e os certificados importam, o que a retomada e o 0-RTT custam e os erros que causam quedas.

14 min de leitura

O TLS (Transport Layer Security) é o que coloca o "s" em https. Ele faz três trabalhos para uma conexão: criptografia (ninguém no caminho consegue ler os dados), integridade (ninguém consegue alterá-los sem ser notado) e autenticação (você está de fato falando com o servidor que queria). Quase toda pergunta sobre ele se resume a como os dois lados combinam uma chave secreta enquanto estranhos escutam, e por que você pode confiar em quem combinou a chave com você. Este guia acompanha um handshake real, mensagem por mensagem.

1. Que problema o TLS resolve

O HTTP sobre TCP puro envia tudo às claras. Qualquer um entre você e o servidor (o dono de um Wi-Fi, um provedor de internet, um roteador comprometido) pode lê-lo e também alterá-lo. O TLS envolve a conexão TCP de modo que:

O que o TLS não esconde: o endereço IP do servidor, a quantidade e o momento do tráfego e (em geral) o nome do servidor enviado na primeira mensagem. E ele não torna o servidor honesto: um site de phishing pode ter um certificado perfeitamente válido para o próprio nome.

2. As ideias de que ele é feito

Três blocos de construção, e o TLS é a receita que os combina.

3. O handshake, mensagem por mensagem

Capturei o handshake de verdade: um servidor local com um certificado autoassinado e openssl s_client -msg como cliente. Estas são as mensagens do handshake na ordem em que passaram pela rede, primeiro o TLS 1.3.

TLS 1.3 (RFC 8446) [1]

client → server   ClientHello           versions, cipher suites, key share (X25519 public value), server name (SNI)
server → client   ServerHello           chosen cipher suite, the server's key share
                  ---- from here on everything is encrypted with keys both sides can now compute ----
server → client   EncryptedExtensions   extra settings (for example the application protocol, h2 or http/1.1)
server → client   Certificate           the certificate chain
server → client   CertificateVerify     a signature over the whole handshake so far, made with the certificate's private key
server → client   Finished              a MAC over the handshake: "this is what I saw"
client → server   ChangeCipherSpec      a leftover with no meaning in 1.3, sent so that middleboxes that expect TLS 1.2 do not drop the connection
client → server   Finished              the same, from the client
                  ---- the application data (the HTTP request) can start now ----

A linha de resumo do cliente na mesma execução: TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384, Server Temp Key: X25519, Verification: OK.

Repare no truque que o torna rápido: o cliente chuta a troca de chaves já na primeira mensagem (ele já envia seu valor X25519 no ClientHello). O servidor responde com o seu próprio valor no ServerHello, e a partir desse momento os dois podem calcular as chaves. Um handshake completo leva uma ida e volta antes que o cliente possa enviar sua requisição.

TLS 1.2 (RFC 5246) para comparação

O mesmo cliente forçado ao TLS 1.2 (-tls1_2):

client → server   ClientHello
server → client   ServerHello
server → client   Certificate           (sent in the clear)
server → client   ServerKeyExchange     the server's ECDHE value, signed
server → client   ServerHelloDone
client → server   ClientKeyExchange     the client's ECDHE value
client → server   ChangeCipherSpec
client → server   Finished
server → client   NewSessionTicket
server → client   ChangeCipherSpec
server → client   Finished

O TLS 1.2 não chuta: o cliente primeiro pergunta o que está disponível e só depois envia seu valor de chave. Isso custa duas idas e voltas. O certificado também trafega sem criptografia, então um observador pode ver qual certificado lhe foi mostrado.

O que as versões mais novas mudaram

TLS 1.2TLS 1.3
Idas e voltas antes da requisição21
Certificado visível a observadoressimnão (criptografado)
Troca de chaves RSA (sem forward secrecy)permitidaremovida
Cifras fracas e recursos antigos (suítes CBC, compressão, renegociação)possíveisremovidos
Retomadasession IDs e ticketschaves pré-compartilhadas

O TLS 1.0 e o 1.1 estão obsoletos (RFC 8996). Hoje um servidor deve oferecer o 1.3 e, para clientes mais antigos, o 1.2.

4. Certificados e a cadeia de confiança

O certificado é uma declaração assinada: "esta chave pública pertence a estes nomes", com datas de validade. Quem a garante?

Diagram: Chain of trust from the server to a root your device already has

5. As coisas em volta do handshake

6. Quanto custa

A latência é contada em idas e voltas (RTT). Antes de o primeiro byte de uma resposta chegar em uma nova conexão:

ConfiguraçãoIdas e voltasCom RTT de 100 ms
TCP + TLS 1.2 + requisição HTTP1 (TCP) + 2 (TLS) + 1 (requisição) = 4400 ms
TCP + TLS 1.3 + requisição HTTP1 + 1 + 1 = 3300 ms
QUIC / HTTP/3 (transporte e TLS 1.3 juntos)1 + 1 = 2200 ms
TCP + TLS 1.3, retomado, com 0-RTT (a requisição vai no primeiro envio)1 (TCP) + 1 (requisição e resposta) = 2200 ms
QUIC, retomado, com 0-RTT1100 ms

Na minha própria máquina, onde a ida e volta é quase zero, o curl informou tcp 0.0002 s, tls cerca de 0,0035 s e first byte cerca de 0,004 s (três execuções: de 3,3 a 4,1 ms para o TLS): o trabalho de chave pública no handshake levou cerca de 3,5 ms, e o custo real do TLS em uma rede de verdade são as idas e voltas, não a criptografia. É por isso que o reaproveitamento de conexões (keep-alive, multiplexação do HTTP/2) e as CDNs perto do usuário importam mais do que qualquer escolha de cifra.

A ferramenta para ver isso você mesmo:

curl -sS -o /dev/null -w 'dns %{time_namelookup}s  tcp %{time_connect}s  tls %{time_appconnect}s  first byte %{time_starttransfer}s\n' https://example.com/

Cada número é cumulativo: o tempo do TLS inclui o tempo de DNS e TCP anteriores.

7. Experimente você mesmo

Crie um certificado e um servidor e observe o handshake:

# 1. a key and a self-signed certificate for localhost
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes \
  -keyout k.pem -out c.pem -subj "/CN=localhost" -days 2 -addext "subjectAltName=DNS:localhost"

# 2. a test server
openssl s_server -accept 4443 -cert c.pem -key k.pem -www

# 3. in another terminal: the handshake messages, for TLS 1.3 and then TLS 1.2
openssl s_client -connect localhost:4443 -tls1_3 -msg -CAfile c.pem -servername localhost
openssl s_client -connect localhost:4443 -tls1_2 -msg -CAfile c.pem -servername localhost

Procure as linhas que começam com <<< (do servidor) e >>> (do cliente). Depois tente -verify_hostname wrong.example e deixe de fora -CAfile c.pem para ver as duas falhas.

No código, os padrões seguros são todo o ponto: use o cliente HTTPS padrão da linguagem, que verifica a cadeia e o nome. Por exemplo (escolha uma linguagem nas abas; sua escolha é lembrada):

import ssl
import urllib.request

ctx = ssl.create_default_context()                     # verifies the chain and the host name
ctx.minimum_version = ssl.TLSVersion.TLSv1_2           # refuse the old versions
with urllib.request.urlopen("https://example.com/", context=ctx, timeout=10) as r:
    print(r.status, r.headers.get("strict-transport-security"))
client := &http.Client{
	Timeout: 10 * time.Second,
	Transport: &http.Transport{
		TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12}, // verification is on by default
	},
}
resp, err := client.Get("https://example.com/")
// Node verifies the chain and the host name by default; never set rejectUnauthorized: false
const https = require("node:https");
https.get("https://example.com/", { minVersion: "TLSv1.2" }, (res) => {
  console.log(res.statusCode, res.headers["strict-transport-security"]);
});
var handler = new SocketsHttpHandler
{
    SslOptions = { EnabledSslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13 }  // verification is on by default
};
using var http = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(10) };
var response = await http.GetAsync("https://example.com/");

8. Erros que aparecem sem parar

9. Perguntas que entrevistadores gostam de acrescentar

"Por que não usar simplesmente a chave pública do servidor para criptografar a chave?"

Dá para fazer (era a troca de chaves RSA do TLS antigo), mas então qualquer um que mais tarde roubar a chave privada do servidor poderá descriptografar todo o tráfego gravado. O Diffie-Hellman efêmero dá forward secrecy, e o TLS 1.3 o tornou obrigatório.

"Como o cliente sabe que o certificado não é falsificado?"

Ele verifica a assinatura da CA nele, subindo por uma cadeia até uma raiz em que já confia. A confiança vem do repositório de raízes, que faz parte do seu sistema operacional ou navegador.

"O que um homem no meio precisa para derrotar o TLS?"

Um certificado em que o cliente confie para aquele nome. É por isso que CAs comprometidas, certificados raiz corporativos instalados e usuários que ignoram os avisos são os ataques reais, e não quebrar a criptografia. Os logs de Certificate Transparency e o HSTS tornam alguns desses ataques mais fáceis de detectar e mais difíceis de explorar.

"Qual é a diferença entre TLS e HTTPS?"

HTTPS é o HTTP transportado sobre TLS. O TLS também protege outros protocolos: SMTP, IMAP, bancos de dados, gRPC, MQTT.

"O que muda com o HTTP/3?"

Ele roda sobre QUIC (em UDP), que embute o TLS 1.3 no transporte: um handshake combinado e sem bloqueio de cabeça de fila entre fluxos. A criptografia é a mesma.

10. Coisas a mencionar em uma entrevista

Resumo rápido

  1. O TLS dá criptografia, integridade e autenticação do servidor sobre o TCP.
  2. Uma troca de chaves nova (ECDHE) por conexão dá forward secrecy; uma assinatura mais um certificado provam com quem você trocou.
  3. O TLS 1.3 precisa de uma ida e volta e criptografa o certificado; o TLS 1.2 precisa de duas.
  4. Os certificados formam uma cadeia até uma raiz no seu repositório de confiança, e o nome no certificado deve coincidir com o que você pediu.
  5. A retomada economiza handshakes; o 0-RTT economiza uma ida e volta, mas pode ser reproduzido, então use-o só para requisições seguras.
  6. O custo real do TLS são as idas e voltas, não a criptografia. Reaproveite conexões.
  7. Nunca desligue a verificação; automatize a renovação; sirva a cadeia inteira.

Fontes

  1. IETF, RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3. O handshake, o key schedule, a retomada e o 0-RTT.
  2. IETF, RFC 8470: Using Early Data in HTTP. Como o replay do 0-RTT é tratado no HTTP.
  3. IETF, RFC 5246: TLS Version 1.2. O handshake mais antigo usado na comparação.
  4. IETF, RFC 6066: TLS Extensions (SNI) e RFC 7301: ALPN.
  5. IETF, RFC 6797: HTTP Strict Transport Security.
  6. IETF, RFC 8996: Deprecating TLS 1.0 and TLS 1.1.
  7. Documentação do OpenSSL, s_client e s_server. As ferramentas usadas no experimento.
  8. Let's Encrypt, How it works (certificados automáticos com ACME) e Certificate lifetime rationale and plans (a validade de 90 dias e a renovação).

Pratique este tema: Networking & APIs

Mais guias