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.

Resposta curta: 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.
Neste artigo
- O que a conta do handshake realmente inclui
- Os 108 ms que medimos e o que esse número já descarta
- Como isolar só o TLS com time_connect e time_appconnect no curl
- Em qual marca do curl a troca de certificado pode aparecer
- O que de fato muda ao sair de RSA 2048 para ECDSA P-256
- O que realmente derruba os 108 ms, e não é o certificado
- Como decidir sem reemitir certificado por engano
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.
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.
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:
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
curlpor 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.2de um lado e--tlsv1.3do 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.
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:
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.
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_connectno seu host, com conexão nova a cada amostra, e pegue a mediana. - Colete as mesmas 100 amostras de
time_connectsozinho. 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.2e 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 -touapachectl configtestantes, e confirme comopenssl s_clientdepois.
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.