Quantum readiness: preparando criptografia para o pós-quântico

1. Por que a criptografia atual está ameaçada?

A criptografia assimétrica que protege a internet hoje — RSA, ECDH, ECDSA — baseia-se em problemas matemáticos que são difíceis para computadores clássicos, mas triviais para um computador quântico suficientemente grande. O algoritmo de Shor, proposto por Peter Shor em 1994, demonstra que a fatoração de inteiros e o logaritmo discreto podem ser resolvidos em tempo polinomial em um computador quântico. Isso significa que uma chave RSA de 2048 bits, que levaria bilhões de anos para ser quebrada classicamente, poderia ser comprometida em minutos com alguns milhares de qubits lógicos.

Para a criptografia simétrica, o cenário é menos catastrófico, mas ainda preocupante. O algoritmo de Grover reduz a segurança efetiva pela metade: um AES-256 ofereceria segurança equivalente a AES-128 contra ataques quânticos. Embora isso ainda seja seguro para a maioria das aplicações, exige a duplicação do tamanho das chaves simétricas.

O horizonte para um computador quântico capaz de quebrar RSA-2048 é estimado entre 10 e 20 anos. Empresas como IBM, Google e IonQ já demonstram processadores com centenas de qubits, e roteiros de engenharia apontam para qubits lógicos estáveis na próxima década.

2. O problema do "Harvest Now, Decrypt Later"

Um dos maiores riscos imediatos não é a quebra de criptografia hoje, mas a coleta de dados criptografados para descriptografia futura. Atacantes podem interceptar tráfego TLS, VPNs, e-mails criptografados e backups armazenados, guardando esses dados até que um computador quântico esteja disponível.

Dados com longa vida útil — registros médicos (obrigação de retenção de décadas), documentos governamentais sigilosos, patentes, contratos financeiros — são particularmente vulneráveis. Se você está transmitindo ou armazenando informações que precisam permanecer confidenciais por mais de 10 anos, elas já estão em risco.

Assinaturas digitais de longa duração, como certificados de CA raiz com validade de 20 anos, também são alvos. Um atacante poderia forjar certificados retroativamente, comprometendo toda a infraestrutura de confiança da web.

A migração para criptografia pós-quântica (PQC) deve começar agora, não quando o primeiro computador quântico for anunciado. O tempo de transição para substituir algoritmos em toda a infraestrutura global é estimado em 5 a 10 anos.

3. Fundamentos da Criptografia Pós-Quântica (PQC)

O NIST (National Institute of Standards and Technology) liderou um processo de seleção de algoritmos PQC, resultando em três padrões principais:

  • CRYSTALS-Kyber (FIPS 203): criptografia de chave pública baseada em reticulados (lattice-based). Oferece encapsulamento de chave (KEM) e substitui RSA/ECDH para troca de chaves.
  • CRYSTALS-Dilithium (FIPS 204): assinatura digital baseada em reticulados, substituta natural do ECDSA e RSA para assinaturas.
  • SPHINCS+ (FIPS 205): assinatura baseada em hash (hash-based), com chaves e assinaturas maiores, mas segurança baseada apenas em funções hash (suposição mais conservadora).

Algoritmos baseados em códigos corretores de erro (Classic McEliece) e isogenias (SIKE) também foram considerados, mas SIKE foi descartado após um ataque prático em 2022, demonstrando a necessidade de cautela.

Comparações práticas mostram diferenças significativas:

Algoritmo Chave pública Chave privada Ciphertext/Assinatura
RSA-2048 256 bytes 512 bytes 256 bytes
Kyber-512 800 bytes 1.632 bytes 768 bytes
Dilithium2 1.312 bytes 2.528 bytes 2.420 bytes
SPHINCS+ 32 bytes 64 bytes 17.088 bytes

4. Estratégias híbridas de transição

A abordagem mais segura para a transição é o uso de algoritmos híbridos: combinar criptografia clássica e pós-quântica, de modo que a segurança seja garantida pelo mais forte dos dois. Se um dos algoritmos for quebrado, o outro ainda protege os dados.

Exemplo de handshake híbrido em TLS 1.3:

Cliente: ClientHello (suporta X25519 + Kyber-768)
Servidor: ServerHello + KeyShare (X25519 + Kyber-768)
Ambos: combinam ECDH(X25519) + KEM(Kyber) via KDF
Resultado: chave de sessão híbrida

Para assinaturas, recomenda-se assinaturas duplas: o certificado contém duas assinaturas (ECDSA + Dilithium), e o verificador escolhe aquela que suporta.

Quando usar híbrido vs. puramente PQC? Em sistemas críticos ou com dados de longa retenção, sempre prefira híbrido. Em ambientes controlados onde todos os participantes são conhecidos e atualizados, PQC puro pode ser usado, mas com monitoramento de possíveis ataques.

5. Implementação prática para desenvolvedores

A biblioteca mais madura para PQC é a liboqs (Open Quantum Safe), que oferece implementações de todos os algoritmos finalistas do NIST. O OpenSSL, a partir da versão 3.5, inclui suporte experimental a Kyber e Dilithium.

Exemplo de geração de chaves Kyber e criptografia/descriptografia usando liboqs (C):

#include <oqs/oqs.h>
#include <stdio.h>
#include <string.h>

int main() {
    OQS_KEM *kem = NULL;
    uint8_t *public_key = NULL;
    uint8_t *secret_key = NULL;
    uint8_t *ciphertext = NULL;
    uint8_t *shared_secret_e = NULL;
    uint8_t *shared_secret_d = NULL;

    kem = OQS_KEM_new(OQS_KEM_alg_kyber_768);

    // Geração de par de chaves
    public_key = malloc(kem->length_public_key);
    secret_key = malloc(kem->length_secret_key);
    OQS_KEM_keypair(kem, public_key, secret_key);

    // Encapsulamento (cliente)
    ciphertext = malloc(kem->length_ciphertext);
    shared_secret_e = malloc(kem->length_shared_secret);
    OQS_KEM_encaps(kem, ciphertext, shared_secret_e, public_key);

    // Decapsulamento (servidor)
    shared_secret_d = malloc(kem->length_shared_secret);
    OQS_KEM_decaps(kem, shared_secret_d, ciphertext, secret_key);

    // Verificação: shared_secret_e == shared_secret_d
    if (memcmp(shared_secret_e, shared_secret_d, 
               kem->length_shared_secret) == 0) {
        printf("Chave compartilhada estabelecida com sucesso!\n");
    }

    OQS_KEM_free(kem);
    free(public_key);
    free(secret_key);
    free(ciphertext);
    free(shared_secret_e);
    free(shared_secret_d);
    return 0;
}

Exemplo de assinatura e verificação com Dilithium:

#include <oqs/oqs.h>
#include <stdio.h>
#include <string.h>

int main() {
    OQS_SIG *sig = NULL;
    uint8_t *public_key = NULL;
    uint8_t *secret_key = NULL;
    uint8_t *message = (uint8_t *)"Mensagem importante";
    size_t message_len = strlen((char *)message);
    uint8_t *signature = NULL;
    size_t signature_len = 0;

    sig = OQS_SIG_new(OQS_SIG_alg_dilithium_2);

    // Geração de chaves
    public_key = malloc(sig->length_public_key);
    secret_key = malloc(sig->length_secret_key);
    OQS_SIG_keypair(sig, public_key, secret_key);

    // Assinatura
    signature = malloc(sig->length_signature);
    OQS_SIG_sign(sig, signature, &signature_len, 
                 message, message_len, secret_key);

    // Verificação
    if (OQS_SIG_verify(sig, message, message_len, 
                       signature, signature_len, public_key) == OQS_SUCCESS) {
        printf("Assinatura verificada com sucesso!\n");
    } else {
        printf("Falha na verificação da assinatura.\n");
    }

    OQS_SIG_free(sig);
    free(public_key);
    free(secret_key);
    free(signature);
    return 0;
}

Boas práticas:
- Sempre valide os tamanhos de chaves e ciphertexts — eles são maiores que RSA/ECC.
- Teste compatibilidade com versões antigas: implemente fallback para algoritmos clássicos.
- Monitore o overhead de rede: Kyber-768 adiciona ~1,5 KB por handshake TLS.

6. Migração de sistemas existentes

A migração deve seguir um plano estruturado:

  1. Auditoria de dependências: identifique todo uso de RSA, ECDSA, ECDH, Diffie-Hellman em seu código, bibliotecas e configurações.
  2. Priorização: sistemas que lidam com dados de longa retenção (bancos de dados criptografados, backups, certificados de CA) devem ser migrados primeiro.
  3. Atualização de certificados X.509: o padrão X.509v3 suporta extensões para incluir chaves públicas PQC. Cadeias híbridas (dois certificados, um clássico e um PQC) são recomendadas.
  4. Testes de regressão: meça desempenho (Kyber é ~10x mais lento que X25519 em CPU, mas em hardware moderno ainda é aceitável), latência e interoperabilidade com clientes antigos.
  5. Plano de rollback: mantenha a infraestrutura clássica funcionando em paralelo. Se um algoritmo PQC for quebrado, desative-o e volte para o clássico.

7. Desafios operacionais e próximos passos

Os principais desafios operacionais incluem:

  • Tamanho de chaves: chaves públicas de Kyber-512 (800 bytes) vs. X25519 (32 bytes) aumentam o armazenamento e a largura de banda. Em sistemas embarcados, isso pode ser crítico.
  • Ciclo de vida: rotação de chaves, revogação e backup devem ser adaptados. Chaves PQC são maiores e os processos de revogação (CRL, OCSP) precisam suportar novos algoritmos.
  • Monitoramento de avanços: a criptoanálise de PQC é ativa. O ataque a SIKE em 2022 mostrou que algoritmos podem cair rapidamente. Acompanhe o NIST e a comunidade acadêmica.

Recomendações finais para desenvolvedores:

  1. Comece hoje: implemente um sandbox com liboqs e teste seus protocolos.
  2. Participe de testes de interoperabilidade (ex: NIST PQC Interop).
  3. Defina um roadmap de quantum readiness para sua organização.
  4. Considere o uso de híbrido como padrão para novos sistemas.

A segurança pós-quântica não é um problema do futuro — é uma responsabilidade do presente. Cada linha de código que você escreve hoje pode estar protegendo dados que serão valiosos por décadas.

Referências