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:
- Confidencialidade: os dados são criptografados com uma chave que só as duas pontas conhecem.
- Integridade: cada registro carrega uma tag de autenticação; um byte alterado a faz falhar.
- Autenticação do servidor: o servidor prova que tem um certificado para o nome que você pediu, emitido por uma autoridade em que seu dispositivo confia. (O cliente também pode ser autenticado, com um certificado de cliente. Isso se chama TLS mútuo, ou mTLS.)
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.
- Criptografia simétrica (AES-GCM, ChaCha20-Poly1305): uma chave compartilhada criptografa e descriptografa. É rápida, então protege todos os dados de verdade. Seu problema: os dois lados precisam da mesma chave, e você não pode enviar a chave às claras.
- Troca de chaves (Diffie-Hellman, em geral a versão de curvas elípticas, ECDHE): duas partes que nunca se encontraram trocam valores públicos e cada uma calcula o mesmo segredo. Um espião vê os valores públicos, mas não consegue calcular o segredo. As chaves são geradas novas a cada conexão ("efêmeras"), o que dá forward secrecy: se a chave de longo prazo do servidor for roubada no ano que vem, o tráfego gravado hoje continua impossível de descriptografar.
- Assinaturas digitais e certificados: a troca de chaves sozinha não diz com quem você trocou. Um homem no meio poderia fazer uma troca com você e outra com o servidor. Então o servidor assina o handshake com a chave privada correspondente ao seu certificado, e o certificado diz "esta chave pública pertence a
example.com", assinado por uma autoridade certificadora (CA).
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.2 | TLS 1.3 | |
|---|---|---|
| Idas e voltas antes da requisição | 2 | 1 |
| Certificado visível a observadores | sim | não (criptografado) |
| Troca de chaves RSA (sem forward secrecy) | permitida | removida |
| Cifras fracas e recursos antigos (suítes CBC, compressão, renegociação) | possíveis | removidos |
| Retomada | session IDs e tickets | chaves 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
- O servidor envia seu certificado folha e os intermediários. O cliente já tem as raízes em um repositório de confiança que acompanha o sistema operacional ou o navegador.
- O cliente verifica cada assinatura ao longo da cadeia, as datas, se a cadeia termina em uma raiz confiável, se o certificado não foi revogado (por OCSP stapling ou validade curta) e se o nome que você pediu consta no certificado (o campo Subject Alternative Name). A verificação do nome é o que impede que um certificado válido de um site seja usado em outro.
- Duas falhas que provoquei de propósito: conectar ao meu servidor com
curlsem uma raiz confiável dáSSL certificate problem: self-signed certificate, eopenssl s_client -verify_hostname wrong.exampledáVerify return code: 62 (hostname mismatch). Nunca "conserte" isso desligando a verificação (curl -k,verify=False): isso dá criptografia sem saber quem está do outro lado, que é exatamente o ataque que o TLS existe para impedir. - O Let's Encrypt e o ACME tornaram os certificados gratuitos e automáticos: a CA verifica que você controla o domínio (por um arquivo no seu site ou um registro DNS), e seu servidor renova o certificado sem intervenção humana. Os certificados do Let's Encrypt valem 90 dias, e ele recomenda renovar bem antes disso (a cada 60 dias) [8]. Validades curtas também reduzem o dano de uma chave roubada.
5. As coisas em volta do handshake
- SNI (Server Name Indication, RFC 6066): um endereço IP pode hospedar centenas de sites, então o cliente diz no
ClientHelloqual nome quer, e o servidor escolhe o certificado correspondente. Normalmente esse nome é visível a observadores. O Encrypted Client Hello (ECH) é a correção mais nova. - ALPN (RFC 7301): na mesma troca, o cliente lista os protocolos de aplicação que fala (
h2,http/1.1) e o servidor escolhe um. É assim que o HTTP/2 é combinado sem uma ida e volta extra. - Retomada de sessão: depois de um primeiro handshake, o servidor dá um ticket ao cliente. Da próxima vez, o cliente o apresenta e pula o certificado e o trabalho caro de chave pública. No TLS 1.3, o cliente pode até enviar sua primeira requisição junto com o
ClientHello(dados antecipados 0-RTT). O preço: um atacante que grave esse primeiro envio pode reproduzi-lo (replay). Por isso o 0-RTT só é seguro para requisições que podem ser repetidas sem dano (umGETde uma página pública), nunca para "pagar" ou "transferir"; os servidores podem recusar dados antecipados, e o HTTP tem um status para dizer "tente de novo depois do handshake" (RFC 8470) [2]. - HSTS (RFC 6797): um cabeçalho (
Strict-Transport-Security: max-age=31536000) que diz aos navegadores "use sempre apenas HTTPS neste site". Ele fecha a brecha em que uma primeira requisição sai porhttp://simples e poderia ser sequestrada. - mTLS: o servidor também pede um certificado ao cliente. Comum entre serviços dentro de uma empresa (as service meshes o automatizam), raro em navegadores.
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ção | Idas e voltas | Com RTT de 100 ms |
|---|---|---|
| TCP + TLS 1.2 + requisição HTTP | 1 (TCP) + 2 (TLS) + 1 (requisição) = 4 | 400 ms |
| TCP + TLS 1.3 + requisição HTTP | 1 + 1 + 1 = 3 | 300 ms |
| QUIC / HTTP/3 (transporte e TLS 1.3 juntos) | 1 + 1 = 2 | 200 ms |
| TCP + TLS 1.3, retomado, com 0-RTT (a requisição vai no primeiro envio) | 1 (TCP) + 1 (requisição e resposta) = 2 | 200 ms |
| QUIC, retomado, com 0-RTT | 1 | 100 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
- Desligar a verificação para "fazer o erro sumir". Corrija a causa: instale a raiz certa, corrija o nome, renove o certificado.
- Um certificado expirado. A queda mais comum de todas. Automatize a renovação e alerte sobre a expiração com bastante antecedência.
- Um intermediário ausente. O site funciona no seu navegador (que guarda intermediários em cache), mas falha no
curlou em um app móvel. Sirva sempre a cadeia completa. - Conteúdo misto: uma página HTTPS carregando um script por HTTP. Os navegadores o bloqueiam, e ele anularia a proteção de qualquer forma.
- Nome errado: o certificado cobre
example.com, mas nãowww.example.com, ou um curinga*.example.comque não cobre o próprioexample.com. - Terminar o TLS em um balanceador de carga e enviar HTTP puro atrás dele, em uma rede que você não controla totalmente. Criptografe por dentro também quando os dados justificarem (veja o guia de balanceamento de carga).
- Versões antigas do protocolo deixadas ligadas. Desative o TLS 1.0 e o 1.1; mantenha o 1.2 só se precisar de clientes antigos.
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
- Nomeie os três trabalhos: criptografia, integridade, autenticação.
- Explique o ECDHE e o forward secrecy em uma frase, e por que as assinaturas são necessárias por cima.
- Percorra o handshake do TLS 1.3 e diga que leva uma ida e volta, contra duas no 1.2.
- Explique a cadeia de confiança e a verificação do nome.
- Mencione SNI, ALPN, retomada e o risco de replay do 0-RTT.
- Diga o que o TLS não protege (metadados, a honestidade do servidor).
Resumo rápido
- O TLS dá criptografia, integridade e autenticação do servidor sobre o TCP.
- Uma troca de chaves nova (ECDHE) por conexão dá forward secrecy; uma assinatura mais um certificado provam com quem você trocou.
- O TLS 1.3 precisa de uma ida e volta e criptografa o certificado; o TLS 1.2 precisa de duas.
- 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.
- 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.
- O custo real do TLS são as idas e voltas, não a criptografia. Reaproveite conexões.
- Nunca desligue a verificação; automatize a renovação; sirva a cadeia inteira.
Fontes
- IETF, RFC 8446: The Transport Layer Security (TLS) Protocol Version 1.3. O handshake, o key schedule, a retomada e o 0-RTT.
- IETF, RFC 8470: Using Early Data in HTTP. Como o replay do 0-RTT é tratado no HTTP.
- IETF, RFC 5246: TLS Version 1.2. O handshake mais antigo usado na comparação.
- IETF, RFC 6066: TLS Extensions (SNI) e RFC 7301: ALPN.
- IETF, RFC 6797: HTTP Strict Transport Security.
- IETF, RFC 8996: Deprecating TLS 1.0 and TLS 1.1.
- Documentação do OpenSSL, s_client e s_server. As ferramentas usadas no experimento.
- 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