# RSA ou ECDSA: a troca não tira os 108 ms

O que muda com ECDSA é CPU do servidor e tamanho da cadeia, não o tempo que o usuário espera. Como separar time_connect de time_appconnect com curl antes de reemitir.

> não há ganho perceptível de latência. Medimos 108,7 ms de handshake no TLS 1.2 e 107,6 ms no TLS 1.3 num mesmo host LiteSpeed no Brasil: se cortar um round trip inteiro de protocolo não moveu o número, trocar o tipo de chave move menos ainda.

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

---

## O que a conta do handshake realmente inclui

Quando alguém pergunta se ECDSA P-256 é mais rápido que RSA 2048, a pergunta costuma vir embrulhada em outra: "meu TTFB está alto, trocar o certificado resolve?". São coisas diferentes, e separar as duas antes de reemitir qualquer coisa economiza uma janela de manutenção.

O handshake TLS de uma conexão nova carrega, na mesma janela de tempo, pelo menos quatro coisas:

- um ou dois round trips de rede, dependendo da versão do protocolo e de haver ou não retomada de sessão;
- a troca de chaves efêmera (ECDHE na prática universal hoje), que é aritmética de curva nos dois lados;
- a assinatura do servidor sobre os parâmetros do handshake, que é onde RSA e ECDSA diferem;
- a verificação dessa assinatura e da cadeia pelo cliente, mais o transporte dos bytes do certificado.

Trocar o tipo de chave mexe no terceiro item (custo de assinar, no servidor) e no quarto (custo de verificar, no cliente, mais os bytes da cadeia que trafegam). O round trip de rede e o ECDHE ficam exatamente onde estavam, e são eles que dominam a conta. É por isso que a troca raramente aparece no percentil que você está olhando.

**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)

## Os 108 ms que medimos e o que esse número já descarta

Na medição que fizemos, o custo mediano do handshake TLS por conexão HTTPS nova até um servidor LiteSpeed no Brasil ficou em **108,7 ms no TLS 1.2** e **107,6 ms no TLS 1.3**. Amostra de 100 conexões, janela de setembro de 2026. Cliente partindo de uma máquina em São Paulo, link fixo, até o host LiteSpeed no Brasil. Ferramenta: `curl` 8.5.0 contra OpenSSL 3.0.13. Uma conexão nova por amostra (um processo `curl` por execução, sem keep-alive reaproveitado e sem retomada de sessão), HTTP/1.1 forçado com `--http1.1` para que a marca de TLS não ficasse embutida em handshake de transporte. O valor por amostra é `time_appconnect - time_connect`, e o número publicado é a mediana das 100, não a média.

Isso é um empate prático. E é um empate informativo, porque o TLS 1.3 corta um round trip inteiro do handshake em relação ao 1.2. Se cortar um round trip de protocolo não moveu o número de forma visível, o fator dominante naquele caminho de rede não era o protocolo. Era o custo de a conexão nova existir: resolver, abrir TCP, esperar a ida e volta.

E aqui vem a inferência que interessa para a sua decisão: a assinatura do servidor é um componente ainda menor que o round trip que o TLS 1.3 eliminou. Se o round trip não apareceu nos 108 ms, a troca de RSA por ECDSA tem ainda menos chance de aparecer. Não medimos RSA contra ECDSA lado a lado, e não vamos fingir que medimos. O que medimos diz onde o tempo está, e o tempo não está na aritmética da chave.

## Como isolar só o TLS com time_connect e time_appconnect no curl

O `curl` entrega as duas marcas que resolvem a discussão. `time_connect` é o instante em que o TCP terminou de abrir. `time_appconnect` é o instante em que o handshake TLS terminou e a camada de aplicação está pronta. A diferença entre os dois é o custo do TLS por cima do transporte.

Isso vale sobre TCP. Em HTTP/3 o handshake TLS 1.3 está embutido no handshake QUIC, os dois acontecem na mesma troca de pacotes e a subtração `time_appconnect - time_connect` deixa de isolar o TLS. Force `--http1.1` ou `--http2` nas amostras se quiser o número comparável.

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

Para isolar só o TLS, em segundos, sem calculadora na mão:

```bash
curl -sS -o /dev/null \
  -w '%{time_appconnect} %{time_connect}\n' https://exemplo.com.br/ \
  | awk '{printf "handshake=%.3f s\n", $1 - $2}'
```

Três cuidados para o número não mentir:

- **Force conexão nova a cada amostra.** Um `curl` por execução, sem `--next`, sem keep-alive reaproveitado. Se você quer o custo da conexão nova, não deixe o cliente retomar sessão.
- **Fixe a versão do protocolo** quando for comparar: `--tlsv1.2 --tls-max 1.2` de um lado e `--tlsv1.3` do outro. Sem isso você está comparando o que o servidor escolheu, não o que você quis testar.
- **Mediana, não média.** Um pico de rede isolado move a média e não move a mediana. Colete e ordene.

```bash
for i in $(seq 1 100); do
  curl -sS -o /dev/null --tlsv1.3 \
    -w '%{time_appconnect} %{time_connect}\n' https://exemplo.com.br/
done | awk '{print $1 - $2}' | sort -n | awk '{a[NR]=$1} END {print a[int(NR/2)]}'
```

## Em qual marca do curl a troca de certificado pode aparecer

| Marca do curl | O que já aconteceu até ali | Muda o custo exclusivo desta etapa |
|---|---|---||
| `time_namelookup` | resolução DNS | não |
| `time_connect` | TCP aberto (SYN, SYN-ACK, ACK) | não |
| `time_appconnect` | handshake TLS concluído | parcialmente: assinatura e tamanho do certificado |
| `time_starttransfer` | primeiro byte da resposta | não por si; herda a variação do `time_appconnect` |
| `time_total` | corpo completo recebido | não por si; herda a variação do `time_appconnect` |

As marcas do `curl` são acumuladas desde o início da requisição: `time_total` contém `time_starttransfer`, que contém `time_appconnect`, que contém `time_connect`. A coluna acima responde pelo custo exclusivo de cada etapa, não pelo acumulado. Qualquer delta de assinatura ou de tamanho de cadeia nasce em `time_appconnect` e se propaga para as duas marcas seguintes, que só mudam por herança.

A única linha onde a troca de chave entra é `time_appconnect`, e mesmo ali ela divide espaço com o round trip, com o ECDHE e com o transporte da cadeia.

## O que de fato muda ao sair de RSA 2048 para ECDSA P-256

Duas coisas reais, e nenhuma delas é o TTFB de uma requisição isolada.

### ECDSA assina mais barato, e isso só importa sob taxa alta de conexões novas

Assinar com ECDSA P-256 é mais barato para o servidor do que assinar com RSA 2048. Verificar é o inverso: RSA verifica barato, ECDSA verifica mais caro. O servidor assina, o cliente verifica. Logo, a economia de CPU fica do seu lado.

Isso só importa se você está com o CPU saturado por handshakes, ou seja, taxa alta de conexões novas por segundo. Meça antes de concluir:

```bash
openssl speed rsa2048
openssl speed ecdsap256
```

Rode no seu hardware, com a sua versão do OpenSSL. Números de benchmark de outro processador não valem como argumento aqui.

### Cadeia menor só vira round trip a menos em link com perda

Uma cadeia ECDSA é menor que uma cadeia RSA equivalente. Em links ruins, com perda e janela inicial pequena, menos bytes no primeiro voo pode significar um round trip a menos. Em link bom, é ruído.

```bash
openssl s_client -connect exemplo.com.br:443 -servername exemplo.com.br </dev/null 2>/dev/null \
  | openssl x509 -noout -text | grep -E 'Public Key Algorithm|Signature Algorithm|Public-Key'
```

## O que realmente derruba os 108 ms, e não é o certificado

Se o objetivo é o número cair, ataque a existência da conexão nova, não a chave.

- **Keep-alive com vida útil decente.** A conexão que não é reaberta custa zero de handshake. Verifique se um proxy intermediário não está fechando antes do tempo.
- **HTTP/2 ou HTTP/3.** Uma conexão, muitas requisições. O custo de 108 ms deixa de ser pago por objeto.
- **Retomada de sessão.** Session tickets no TLS 1.3 com 0-RTT, onde for seguro (lembrando que 0-RTT não tem proteção contra replay e não deve carregar requisição não idempotente).
- **OCSP stapling.** Sem stapling, o cliente pode ter que fazer uma validação externa própria. Confira: `openssl s_client -status -connect host:443`.
- **Proximidade.** Se o round trip domina, o que muda o número é o servidor estar mais perto do usuário, não o certificado ser outro.

Nenhum desses itens exige reemitir certificado.

## Como decidir sem reemitir certificado por engano

- Colete 100 amostras de `time_appconnect - time_connect` no seu host, com conexão nova a cada amostra, e pegue a mediana.
- Colete as mesmas 100 amostras de `time_connect` sozinho. Compare os dois. Se o TCP responde pela maior fatia, o certificado não é o problema e a conversa acabou.
- Se o TLS pesa e você quer confirmar que é assinatura e não round trip, repita com `--tlsv1.2` e com `--tlsv1.3`. Se o número não mexe entre as duas versões, o round trip é o custo e a chave também não vai mexer.
- Se mesmo assim quiser ECDSA, sirva as duas cadeias em paralelo (RSA e ECDSA no mesmo vhost) antes de descontinuar a RSA. LiteSpeed, nginx e Apache suportam múltiplos certificados por host. Cliente antigo que não negocia ECDSA continua funcionando.
- Reverter é trocar o caminho do certificado de volta e recarregar o serviço. Teste o reload com `nginx -t` ou `apachectl configtest` antes, e confirme com `openssl s_client` depois.

A recomendação honesta: ECDSA P-256 é uma boa escolha padrão para certificado novo, por CPU e por tamanho de cadeia. Mas reemitir um certificado RSA que está funcionando para caçar latência é otimizar a parte errada do gráfico. Os 108 ms não estão lá.

---

## 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.
