# O handshake TLS custa 108 ms, e trocar de versão não resolve

O que o visitante paga em DNS, TCP e TLS antes do primeiro byte, medido com curl em 100 conexões, e as três mudanças que realmente reduzem esse tempo.

> o handshake TLS custa cerca de 108 ms por conexão HTTPS nova (108,7 ms no TLS 1.2 contra 107,6 ms no TLS 1.3, em 100 conexões medidas). Quem corta esse tempo não é a versão do protocolo: é a conexão nova não precisar existir, com HTTP/2 ativo, keep-alive preservado e menos domínios de terceiros.

João Rizzon · 2026-09-04 · Infraestrutura web

---

## O que o visitante paga antes de ver o primeiro pixel

Antes de o servidor sequer ler o pedido, o navegador precisa cumprir três etapas em série numa origem que ele nunca visitou:

- **DNS**: descobrir o IP do domínio.
- **TCP**: abrir a conexão com esse IP (o famoso three-way handshake).
- **TLS**: negociar cifra, validar o certificado e derivar as chaves.

Só depois disso a requisição HTTP sai. TTFB, otimização de banco, cache de página: nada disso é acionado enquanto essas três etapas não terminam. É tempo morto do ponto de vista da aplicação e tempo bem vivo do ponto de vista de quem está olhando a tela branca.

Neste artigo, sempre que falamos em custo do handshake TLS, é a definição que o `curl` mede: `time_appconnect` menos `time_connect`, ou seja, o intervalo entre a conexão TCP estabelecida e o handshake TLS concluído. Não inclui DNS, não inclui TCP, não inclui a resposta do servidor. É só o pedágio criptográfico.

**108 ms** custo mediano do handshake TLS por conexão HTTPS nova até um servidor LiteSpeed no Brasil: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3, um empate na prática que mostra que o custo real é a conexão nova existir, não a versão do protocolo (n=100, setembro de 2026)

## TLS 1.2 e TLS 1.3 deram empate em 100 conexões

A promessa que circula em quase todo conteúdo sobre o assunto é que trocar TLS 1.2 por TLS 1.3 acelera o site. A justificativa teórica existe: o handshake completo do TLS 1.2 gasta dois round trips, o do TLS 1.3 gasta um. Em uma rota longa, um round trip a menos aparece.

Em 100 conexões novas contra um servidor LiteSpeed hospedado no Brasil, em setembro de 2026, o resultado foi este:

| Versão do protocolo | Custo mediano do handshake |
|---|---||
| TLS 1.2 | 108,7 ms |
| TLS 1.3 | 107,6 ms |
| Diferença | 1,1 ms |

Um round trip a menos rendeu 1,1 ms de mediana. Para efeito prático, empate. O ganho está dentro do ruído de qualquer página real, onde uma imagem mal comprimida custa dez vezes mais que isso.

O que essa medição não diz, e é importante ser explícito:

- Ela mede uma origem, uma rota e um servidor. Não é média de mercado.
- Ela não isola o RTT da rota, o tempo de CPU do servidor nem o custo de validação da cadeia do certificado dentro do total.
- Ela não mediu 0-RTT (early data) do TLS 1.3, que é outro mecanismo, com outras implicações de segurança para requisições não idempotentes.
- Ela não mediu rota internacional. Em uma conexão intercontinental, com RTT muito maior, o round trip extra do TLS 1.2 tende a pesar mais. Não medimos isso, então não afirmamos.

A conclusão que a amostra sustenta é limitada e útil: **em uma rota nacional, mudar a versão do TLS não é a alavanca de performance**. O que custa é a conexão nova existir. Cada origem nova que a página aciona paga esse pedágio de novo, e paga integralmente.

TLS 1.3 continua valendo a pena. Só que pelo motivo certo: ele remove cifras e modos de negociação problemáticos e simplifica a superfície de ataque. Ative por segurança, não por velocidade.

## Medir o handshake do seu próprio site com curl

O `curl` expõe todos os marcos de tempo da conexão. Cada valor é contado desde o início da requisição, então a duração de cada etapa é a subtração de dois marcos.

### Uma requisição, com o tempo de cada etapa

```bash
curl -s -o /dev/null \
  -w 'dns=%{time_namelookup} tcp=%{time_connect} tls=%{time_appconnect} ttfb=%{time_starttransfer} total=%{time_total}\n' \
  https://exemplo.com.br/
```

Os valores saem em segundos, com casas decimais. Leia assim:

| Etapa | Cálculo |
|---|---||
| DNS | `time_namelookup` |
| TCP | `time_connect` menos `time_namelookup` |
| TLS | `time_appconnect` menos `time_connect` |
| Servidor + rede até o 1º byte | `time_starttransfer` menos `time_appconnect` |

### Cem conexões novas e a mediana do handshake

Uma requisição isolada não vale nada: cache de DNS, variação de rota e concorrência no servidor mexem muito no número. Repita e tire a mediana. Cada invocação do `curl` abre uma conexão nova, que é exatamente o cenário que queremos medir.

```bash
for i in $(seq 1 100); do
  curl -s -o /dev/null \
    -w '%{time_connect} %{time_appconnect}\n' \
    https://exemplo.com.br/
done | awk '{print ($2-$1)*1000}' | sort -n | sed -n '50,51p'
```

As duas linhas impressas são os valores centrais da amostra, em milissegundos. A mediana é a média entre elas. Use mediana, não média: um único pico de 900 ms distorce a média e não representa a experiência típica.

### Comparar TLS 1.2 e TLS 1.3 no seu servidor

Para reproduzir a comparação, force a versão em cada rodada:

```bash
# TLS 1.2
curl -s -o /dev/null --tlsv1.2 --tls-max 1.2 \
  -w '%{time_connect} %{time_appconnect}\n' https://exemplo.com.br/

# TLS 1.3
curl -s -o /dev/null --tlsv1.3 \
  -w '%{time_connect} %{time_appconnect}\n' https://exemplo.com.br/
```

Se o comando com `--tlsv1.3` falhar, ou o seu `curl` foi compilado com uma biblioteca TLS antiga, ou o servidor não oferece 1.3. `curl -V` mostra a biblioteca e a versão.

Rode as duas séries intercaladas, não uma depois da outra. Se você medir TLS 1.2 às 3h e TLS 1.3 às 15h, está medindo carga do servidor, não protocolo.

## Conferir se o HTTP/2 está mesmo ativo

HTTP/2 multiplexa várias requisições dentro de uma única conexão. Em HTTP/1.1 o navegador também reaproveita conexões, mas precisa abrir várias em paralelo para não serializar os downloads: o limite típico é de seis conexões por origem. São seis handshakes na mesma origem, e mais uma fila de espera quando a página tem dezenas de arquivos. Com HTTP/2, uma conexão por origem dá conta de todas as requisições ao mesmo tempo. Só que ele precisa estar ligado, e em mais de um servidor ele não vem ligado por padrão.

### Descobrir a versão do HTTP negociada pelo terminal

```bash
curl -s -o /dev/null --http2 -w '%{http_version}\n' https://exemplo.com.br/
```

A saída é `2` quando o servidor negociou HTTP/2 e `1.1` quando caiu para HTTP/1.1. O `--http2` só autoriza o curl a tentar; quem decide é o servidor, via ALPN, durante o handshake TLS.

### Ler a coluna Protocol na aba Network do navegador

Abra o DevTools, vá em Network, recarregue a página. A coluna que interessa é **Protocol**, e ela costuma vir oculta: clique com o botão direito na linha de cabeçalho da tabela e marque Protocol. Os valores são `h2` (HTTP/2), `h3` (HTTP/3 sobre QUIC) e `http/1.1`.

Olhe linha a linha, não só a primeira. É comum o HTML principal vir em `h2` e um subdomínio de imagens ou um endpoint de API da mesma casa continuar em `http/1.1`.

### No Nginx, HTTP/2 é opt-in e a diretiva mudou na 1.25.1

No Nginx, HTTP/2 é opt-in. A partir da versão 1.25.1 a forma correta é a diretiva própria:

```nginx
server {
    listen 443 ssl;
    http2 on;

    server_name exemplo.com.br;
    # ...
}
```

Em versões anteriores a 1.25.1, o parâmetro ia no `listen`:

```nginx
listen 443 ssl http2;
```

Confira a sua versão com `nginx -v` antes de editar. Depois de aplicar, valide com `nginx -t` e recarregue. E confirme com o comando `curl` acima, não com a leitura do arquivo: um `server` block mais específico ou um proxy na frente pode estar respondendo no lugar do que você editou.

No Apache, HTTP/2 depende do `mod_http2` carregado e da diretiva `Protocols h2 http/1.1`. No LiteSpeed e no OpenLiteSpeed, a negociação é configurada no listener. Em qualquer um dos três, a verificação final é a mesma: o `%{http_version}` que voltou.

## A conexão que já existe custa zero de handshake

Keep-alive é a conexão TCP/TLS ficar aberta depois da resposta, esperando a próxima requisição. Quando ela é reaproveitada, o custo de handshake da segunda requisição é zero, porque não há handshake.

Dá para ver isso acontecendo. Passe duas URLs para o mesmo `curl`, que reutiliza a conexão entre elas:

```bash
curl -s -o /dev/null -o /dev/null \
  -w 'tls=%{time_appconnect} total=%{time_total}\n' \
  https://exemplo.com.br/ https://exemplo.com.br/sobre/
```

A primeira linha traz um `time_appconnect` diferente de zero. A segunda traz `0.000000`. Não é bug do curl: é a definição. Sem conexão nova, não há tempo de handshake para contar.

Se a segunda linha vier com valor diferente de zero, alguma coisa está fechando a conexão. Suspeitos, em ordem de frequência:

- Cabeçalho `Connection: close` na resposta, vindo da aplicação ou de um middleware.
- `keepalive_timeout 0` no Nginx. O padrão da distribuição oficial é 75 segundos.
- Limite baixo de requisições por conexão (`keepalive_requests` no Nginx). O padrão varia entre versões, então confira a documentação da sua e não a de um tutorial antigo.
- Um proxy reverso, CDN ou load balancer na frente que não mantém keep-alive no lado de trás.

Inspecione o cabeçalho direto:

```bash
curl -sI https://exemplo.com.br/ | grep -i '^connection'
```

Um detalhe que engana muita gente: em HTTP/2 o cabeçalho `Connection` é proibido pelo protocolo, e a persistência é intrínseca. Se você está em `h2`, não procure `Connection: keep-alive`. Procure o `time_appconnect` zerado na segunda requisição.

## Cada domínio de terceiro é um pedágio inteiro

Multiplexação e keep-alive resolvem o custo dentro da sua origem. Não fazem nada por um domínio diferente. Fonte externa, gerenciador de tags, widget de chat, pixel de rede social, player de vídeo, mapa: cada origem distinta paga a sequência completa de DNS, TCP e TLS antes de entregar o primeiro byte dela.

Como contar quantas origens a sua página aciona, sem instalar nada:

- DevTools, aba Network, recarregue com o cache desativado.
- Ordene pela coluna Domain.
- Conte os domínios distintos. Esse é o número de pedágios que a sua página cobra do visitante.

O que costuma render mais, em ordem de esforço contra retorno:

- **Hospedar a fonte no próprio domínio.** Elimina uma origem inteira e evita que o texto fique invisível esperando um terceiro.
- **Adiar o widget de chat.** Carregue o script depois do `load`, ou só no clique de um botão. Ele quase nunca é necessário no primeiro segundo.
- **Auditar tags que ninguém usa mais.** Pixel de campanha encerrada há dois anos continua custando handshake em toda visita.
- **Consolidar assets próprios em uma origem só.** Um subdomínio separado para estáticos fazia sentido em HTTP/1.1, para driblar o limite de seis conexões por host. Em HTTP/2, ele só adiciona um handshake.

Para as origens que precisam ficar, `<link rel="preconnect">` antecipa DNS, TCP e TLS para o começo do carregamento. Ele não elimina o custo, só o tira do caminho crítico. Use com parcimônia, em duas ou três origens que você sabe que serão usadas. Preconnect em domínio que a página não chega a acionar é desperdício de conexão e de bateria no celular.

## Por onde começar e o que deixar para o final

| Ação | Efeito no tempo até o primeiro byte | Como confirmar |
|---|---|---||
| Ativar HTTP/2 | Alto, se estava em HTTP/1.1 com muitos assets | `%{http_version}` retorna `2` |
| Preservar keep-alive | Alto em navegação de várias páginas | `time_appconnect` zerado na 2ª requisição |
| Remover origens de terceiros | Proporcional ao número de origens cortadas | Contagem de domínios na aba Network |
| Hospedar a fonte localmente | Uma origem a menos, mais fim do texto invisível | Aba Network, sem o domínio da fonte |
| Trocar TLS 1.2 por TLS 1.3 | Praticamente nulo na rota medida | Comparação com `--tlsv1.2` e `--tlsv1.3` |
| Preconnect em origem essencial | Tira o custo do caminho crítico, não o elimina | Waterfall, conexão iniciada mais cedo |

A ordem prática: confirme HTTP/2 primeiro, porque é uma linha de configuração e pode estar desligada sem ninguém ter notado. Depois confirme keep-alive, porque a segunda página da navegação depende dele. Só então mexa em terceiros, que é o trabalho mais chato e o de maior retorno em páginas pesadas de marketing.

Deixe a versão do TLS para o final da lista de performance e trate como item de segurança. Se um fornecedor está vendendo migração de plano com a promessa de que TLS 1.3 vai acelerar o seu site, peça o número medido dele. A nossa amostra de 100 conexões, em setembro de 2026, contra um LiteSpeed no Brasil, deu 1,1 ms de diferença mediana entre as duas versões.

E meça antes de mudar. Rode o loop de 100 conexões hoje, guarde a mediana, aplique uma mudança de cada vez e rode de novo. Sem linha de base, qualquer resultado depois parece bom.

---

## Como medimos

100 conexões HTTPS novas de um VPS externo a um servidor LiteSpeed da Napoleon: 50 negociando TLS 1.2 e 50 negociando TLS 1.3. Em cada conexão o curl registrou time_connect (fim do TCP) e time_appconnect (fim do TLS); o custo do handshake é a diferença entre os dois, isolando o TLS do TCP. Medianas: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3.
