blog
Infraestrutura web

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.

JR · · 7 min de leitura · 1 tabela · 5 blocos de código

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
  1. O que a conta do handshake realmente inclui
  2. Os 108 ms que medimos e o que esse número já descarta
  3. Como isolar só o TLS com time_connect e time_appconnect no curl
  4. Em qual marca do curl a troca de certificado pode aparecer
  5. O que de fato muda ao sair de RSA 2048 para ECDSA P-256
  6. O que realmente derruba os 108 ms, e não é o certificado
  7. 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:

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 100 amostras · setembro de 2026 · medido pela Napoleon Host

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:

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.

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.

Nenhum desses itens exige reemitir certificado.

Como decidir sem reemitir certificado por engano

  1. Colete 100 amostras de time_appconnect - time_connect no seu host, com conexão nova a cada amostra, e pegue a mediana.
  2. 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.
  3. 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.
  4. 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.
  5. 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.

Leia também