# Quantum-safe cryptography: preparando sistemas de CPF para a era pós-quântica

> Entenda como a computação quântica ameaça a criptografia atual e como preparar sistemas de CPF para a era pós-quântica.

**Publicado:** 11/11/2025
**Autor:** Redação CPFHub.io
**URL:** https://cpfhub.io/blog/quantum-safe-cryptography-preparando-sistemas-de-cpf-para-a-era-pos-quantica

---


A computação quântica representa uma ameaça concreta à criptografia que protege dados de CPF em trânsito e em repouso. Sistemas que utilizam a API CPFHub.io já se beneficiam de TLS 1.3 e AES-256 — mas a migração para algoritmos pós-quânticos padronizados pelo NIST deve ser planejada desde já para proteger dados sensíveis na era pós-quântica.

## Introdução

A computação quântica está evoluindo rapidamente. Embora computadores quânticos universais ainda não sejam capazes de quebrar a criptografia atual, especialistas estimam que isso pode acontecer entre 2030 e 2040. Quando isso ocorrer, os algoritmos criptográficos que protegem dados de CPF em trânsito e em repouso -- RSA, ECC, AES em certos modos -- estarão vulneráveis.

O conceito de "harvest now, decrypt later" torna essa ameaça imediata: adversários podem interceptar e armazenar dados criptografados hoje para descriptografá-los quando computadores quânticos estiverem disponíveis. Para dados de longa duração como CPFs, isso é especialmente preocupante.

---

## A ameaça quântica à criptografia atual

### Algoritmo de Shor

O algoritmo de Shor, executável em computadores quânticos, pode fatorar números inteiros em tempo polinomial. Isso quebra:

- **RSA** -- baseado na dificuldade de fatoração.
- **ECC (Elliptic Curve Cryptography)** -- baseado no problema do logaritmo discreto.
- **Diffie-Hellman** -- usado em troca de chaves TLS.

### Algoritmo de Grover

O algoritmo de Grover reduz pela metade a segurança efetiva de algoritmos simétricos. AES-128 passaria a ter segurança equivalente a 64 bits -- insuficiente. AES-256 passaria a 128 bits -- ainda seguro.

### O que está em risco nos sistemas de CPF

| Componente | Algoritmo atual | Vulnerabilidade quantica |
|---|---|---|
| TLS (API em transito) | RSA/ECC + AES | Troca de chaves vulneravel |
| Banco de dados (em repouso) | AES-256 | Seguro com Grover (128 bits efetivos) |
| Hashing de CPF | SHA-256 | Seguro com Grover (128 bits efetivos) |
| Assinatura de tokens JWT | RSA-256 / ES256 | Vulneravel (Shor) |
| Certificados SSL | RSA-2048 / ECC P-256 | Vulneravel (Shor) |

---

## Algoritmos pós-quânticos padronizados pelo NIST

O NIST (National Institute of Standards and Technology) finalizou a padronização de algoritmos pós-quânticos resistentes a ataques quânticos. Os padrões estão disponíveis em [csrc.nist.gov](https://csrc.nist.gov/projects/post-quantum-cryptography).

### ML-KEM (CRYSTALS-Kyber)

Algoritmo de encapsulamento de chave (Key Encapsulation Mechanism) baseado em lattices. Substitui RSA e ECC na troca de chaves.

### ML-DSA (CRYSTALS-Dilithium)

Algoritmo de assinatura digital baseado em lattices. Substitui RSA e ECDSA na assinatura de certificados e tokens.

### SLH-DSA (SPHINCS+)

Algoritmo de assinatura digital baseado em hash. Alternativa ao Dilithium, com segurança baseada em premissas mais conservadoras.

---

## Estratégia de migração para criptografia pós-quântica

A migração não é um evento único -- é um processo gradual que deve começar agora.

### Fase 1 -- Inventário criptográfico (agora)

Identifique todos os pontos do seu sistema que usam criptografia e quais algoritmos estão em uso.

```javascript
// Conceito: Inventário criptográfico automatizado
function inventarioCriptografico() {
 const inventario = {
 tls: {
 versao: 'TLS 1.3',
 cipherSuites: [
 'TLS_AES_256_GCM_SHA384',
 'TLS_CHACHA20_POLY1305_SHA256'
 ],
 trocaChaves: 'X25519 (ECC -- vulnerável a Shor)',
 certificado: 'RSA-2048 (vulnerável a Shor)',
 status: 'MIGRAR'
 },
 apiKeys: {
 algoritmo: 'HMAC-SHA256',
 comprimento: 256,
 status: 'SEGURO (Grover reduz para 128 bits efetivos)'
 },
 armazenamento: {
 algoritmo: 'AES-256-GCM',
 status: 'SEGURO (Grover reduz para 128 bits efetivos)'
 },
 hashing: {
 algoritmo: 'SHA-256',
 uso: 'Hashing de CPF para logs de auditoria',
 status: 'SEGURO (Grover reduz para 128 bits efetivos)'
 },
 jwt: {
 algoritmo: 'RS256 (RSA)',
 status: 'MIGRAR para ML-DSA'
 }
 };

 return inventario;
}
```

### Fase 2 -- Criptografia híbrida (2025-2027)

Use criptografia híbrida -- combinando algoritmos clássicos com pós-quânticos. Isso garante segurança mesmo se um dos algoritmos for comprometido.

```javascript
// Conceito: TLS híbrido com X25519 + ML-KEM
// Exemplo de configuração conceitual para servidor HTTPS

const tlsOptions = {
 // Ciphers hibridos: classico + pos-quantico
 ciphers: [
 'TLS_AES_256_GCM_SHA384',
 ].join(':'),
 // Grupos de troca de chaves hibridos
 // X25519Kyber768 combina ECC classico com ML-KEM pos-quantico
 ecdhCurve: 'X25519:P-256',
 // Em breve: X25519Kyber768Draft00
 minVersion: 'TLSv1.3'
};

// Nota: o suporte a grupos hibridos PQ esta sendo adicionado
// em runtimes como Node.js e navegadores (Chrome 124+)
```

### Fase 3 -- Migração completa (2027-2030)

Substituir completamente algoritmos clássicos vulneráveis por pós-quânticos padronizados.

---

## Protegendo dados de CPF em trânsito

A principal vulnerabilidade está na troca de chaves TLS. Mesmo que os dados sejam criptografados com AES-256 (seguro contra Grover), a chave de sessão é negociada via RSA ou ECC -- vulneráveis ao algoritmo de Shor.

### Mitigação imediata

Certifique-se de que seu sistema usa TLS 1.3, que oferece forward secrecy. Isso limita o impacto de um eventual comprometimento futuro da chave privada do servidor.

```javascript
// Verificar suporte a TLS 1.3 em uma chamada à API
const https = require('https');

async function verificarTLS() {
 const controller = new AbortController();
 const timeoutId = setTimeout(() => controller.abort(), 10000);

 try {
 const res = await fetch('https://api.cpfhub.io/cpf/00000000000', {
 headers: {
 'x-api-key': 'TEST_KEY',
 'Accept': 'application/json'
 },
 signal: controller.signal
 });
 clearTimeout(timeoutId);

 // Em Node.js, inspecionar o socket TLS
 // res.socket.getProtocol() => 'TLSv1.3'
 // res.socket.getCipher() => { name: 'TLS_AES_256_GCM_SHA384', ... }

 console.log('Conexao TLS estabelecida com sucesso');
 } catch (err) {
 clearTimeout(timeoutId);
 console.error('Erro na verificacao TLS:', err.message);
 }
}
```

---

## Protegendo dados de CPF em repouso

Dados de CPF armazenados em banco de dados já estão relativamente seguros se criptografados com AES-256, que mantém 128 bits de segurança efetiva contra ataques quânticos (via Grover). Porém, é importante garantir que:

- A chave de criptografia AES não é protegida por RSA ou ECC (que seriam vulneráveis).
- O gerenciamento de chaves usa algoritmos resistentes a ataques quânticos.

```javascript
// Conceito: Criptografia de CPF com AES-256-GCM (seguro contra Grover)
const crypto = require('crypto');

function criptografarCPF(cpf, chave) {
 const iv = crypto.randomBytes(12); // 96 bits para GCM
 const cipher = crypto.createCipheriv('aes-256-gcm', chave, iv);

 let encrypted = cipher.update(cpf, 'utf8', 'hex');
 encrypted += cipher.final('hex');
 const authTag = cipher.getAuthTag();

 return {
 dados: encrypted,
 iv: iv.toString('hex'),
 tag: authTag.toString('hex')
 };
}

function descriptografarCPF(dadosCriptografados, chave) {
 const decipher = crypto.createDecipheriv(
 'aes-256-gcm',
 chave,
 Buffer.from(dadosCriptografados.iv, 'hex')
 );
 decipher.setAuthTag(Buffer.from(dadosCriptografados.tag, 'hex'));

 let decrypted = decipher.update(dadosCriptografados.dados, 'hex', 'utf8');
 decrypted += decipher.final('utf8');
 return decrypted;
}

// A chave AES-256 deve ser gerada com entropia suficiente
// e armazenada em um HSM (Hardware Security Module)
const chave = crypto.randomBytes(32);
const cpfCriptografado = criptografarCPF('12345678901', chave);
const cpfOriginal = descriptografarCPF(cpfCriptografado, chave);
```

---

## Tokens JWT pós-quânticos

Se seu sistema usa JWT para autenticação de APIs, os tokens assinados com RSA ou ECDSA serão vulneráveis. A migração para ML-DSA (Dilithium) é necessária.

```javascript
// Conceito: JWT com assinatura pós-quântica (futuro)
// Quando bibliotecas JS suportarem ML-DSA nativamente

/*
const jwt = require('jsonwebtoken-pq'); // Biblioteca conceitual

// Gerar par de chaves ML-DSA (Dilithium)
const { publicKey, privateKey } = await generateMLDSAKeyPair();

// Assinar token
const token = jwt.sign(
 { sub: 'cpf_hash_abc123', iss: 'minha-fintech' },
 privateKey,
 { algorithm: 'ML-DSA-65' } // Dilithium nivel 3
);

// Verificar token
const decoded = jwt.verify(token, publicKey, { algorithms: ['ML-DSA-65'] });
*/

// Por enquanto, mitigacao: usar tokens de curta duracao (15 min)
// Isso limita a janela de "harvest now, decrypt later"
const jwt = require('jsonwebtoken');

const token = jwt.sign(
 { sub: 'cpf_hash_abc123' },
 process.env.JWT_SECRET,
 { expiresIn: '15m' } // Curta duracao como mitigacao
);
```

---

## Cronograma de preparação

| Período | Ação | Prioridade |
|---|---|---|
| 2025 | Inventario criptográfico | Alta |
| 2025-2026 | Garantir TLS 1.3 em todas as comunicacoes | Alta |
| 2026 | Implementar AES-256 para dados em repouso | Media |
| 2026-2027 | Testar criptografia híbrida em ambientes de staging | Media |
| 2027-2028 | Migrar troca de chaves para ML-KEM híbrido | Alta |
| 2028-2029 | Migrar assinaturas para ML-DSA | Alta |
| 2030 | Migração completa para algoritmos pos-quanticos | Alta |

---

## O que a CPFHub.io já faz

A API da [**CPFHub.io**](https://www.cpfhub.io/) já implementa as melhores práticas de segurança disponíveis:

- **TLS 1.3** em todas as comunicações, com forward secrecy.
- **AES-256** para dados em repouso -- seguro contra Grover.
- **Monitoramento contínuo** de ameaças e atualizações de segurança.
- **99,9% de uptime** com infraestrutura redundante.

À medida que algoritmos pós-quânticos se tornem padrão em bibliotecas e runtime environments, a CPFHub.io estará entre os primeiros a adotá-los.

---

## Perguntas frequentes

### O que é necessário para implementar validação de CPF neste contexto?
A validação de CPF exige uma chamada à API com o número do documento e a chave de autenticação. A CPFHub.io retorna o status do CPF, nome do titular e data de nascimento com latência de ~900ms, permitindo a verificação em tempo real durante o cadastro ou transação.

### A API CPFHub.io funciona para todos os volumes de consulta?
Sim. O plano gratuito oferece 50 consultas por mês sem cartão de crédito — ideal para testes e projetos pequenos. Para volumes maiores, o plano Pro inclui 1.000 consultas mensais por R$149. Se o limite for ultrapassado, a API não bloqueia: cobra R$0,15 por consulta adicional.

### Como garantir conformidade com a LGPD ao usar uma API de CPF?
Use o CPF apenas para a finalidade declarada ao titular, armazene apenas o necessário (não guarde o CPF cru se um token bastar), implemente controle de acesso aos logs de consulta e documente a base legal para o tratamento. A [ANPD](https://www.gov.br/anpd) orienta que dados de identificação devem ser tratados com o princípio da necessidade.

### Quanto tempo leva para integrar a API CPFHub.io?
A integração básica leva menos de 30 minutos: crie uma conta em cpfhub.io, gere a API key no painel e faça uma chamada GET para `https://api.cpfhub.io/cpf/{CPF}` com o header `x-api-key`. A documentação inclui exemplos em Python, Node.js, PHP, Java e outras linguagens.

### Leia também

- [Diferença entre validação de CPF e consulta de CPF: quando usar cada uma](https://cpfhub.io/blog/diferenca-entre-validacao-de-cpf-e-consulta-de-cpf-quando-usar-cada-uma)
- [API de CPF grátis para desenvolvedores: como começar em 5 minutos](https://cpfhub.io/blog/api-cpf-gratis-desenvolvedores-comecar-5-minutos)
- [Onboarding digital em fintechs: como validar CPF em menos de 30 segundos](https://cpfhub.io/blog/onboarding-digital-em-fintechs-como-validar-cpf-em-menos-de-30-segundos)
- [KYC no Brasil: quais setores são obrigados a validar CPF por lei](https://cpfhub.io/blog/kyc-no-brasil-quais-setores-sao-obrigados-a-validar-cpf-por-lei)

---

## Conclusão

A ameaça quântica à criptografia não é uma questão de "se", mas de "quando". Para sistemas que processam dados sensíveis como CPFs, a preparação deve começar agora. O inventário criptográfico, a adoção de TLS 1.3, a criptografia AES-256 em repouso e o planejamento para migração para algoritmos pós-quânticos são passos que todo desenvolvedor e arquiteto deve tomar.

Cadastre-se em [cpfhub.io](https://www.cpfhub.io/) — 50 consultas mensais gratuitas, sem cartão de crédito — e comece hoje mesmo.