Fundamentos
Por Que Criptografia Pós-Quântica?
A criptografia moderna baseia-se em problemas computacionalmente difíceis para computadores clássicos. O algoritmo de Shor (1994), quando rodando em um computador quântico com qubits lógicos suficientes, resolve em tempo polinomial os dois pilares da criptografia assimétrica atual.
RSA-2048
Base: fatoração de inteiros (NP-difícil classicamente)
Shor: O(n³) — destrói RSA em qualquer tamanho de chave
ECDH P-256 / X25519
Base: logaritmo discreto em curvas elípticas
Shor quebra grupos abelianos finitos — inclui todas as curvas
ML-KEM-768 (FIPS 203)
Base: Module-LWE — sem estrutura de grupo abeliano
Shor não se aplica. ~178 bits de segurança pós-quântica
BGV / FHE (RLWE)
Base: Ring-LWE — problemas de reticulados
Mesmo problema subjacente ao ML-KEM. Grover: ~128-bit efetivo
Vulnerabilidade por Algoritmo
| Algoritmo | Vulnerável a Shor? | Afetado por Grover? | Status |
|---|---|---|---|
| RSA-2048/4096 | SIM | Não diret. | QUEBRADO por QC |
| ECDH P-256 | SIM | Não diret. | QUEBRADO por QC |
| ECDSA / EdDSA | SIM | Não diret. | QUEBRADO por QC |
| AES-128 | Não | Grover: 64-bit | Marginal — migrar AES-256 |
| AES-256 | Não | 128-bit efetivo | Seguro |
| SHA-256 | Não | 128-bit preimagem | Seguro |
| ML-KEM-768 | NÃO | ~168-bit | FIPS 203 — Nível 3 |
| ML-DSA-65 | NÃO | ~165-bit | FIPS 204 — Nível 3 |
| BGV/RLWE | NÃO | ~128-bit | Quantum-safe |
O Algoritmo de Grover e Seu Impacto em Simétricos
Grover oferece aceleração quadrática para busca não-estruturada — não polinomial como Shor. Para AES com espaço de chaves $N = 2^{256}$:
AES-256: $2^{256} \xrightarrow{\text{Grover}} 2^{128}$ — ainda seguro, mas com margem reduzida. Conclusão prática: dobrar chaves simétricas é suficiente. Chave pública clássica precisa ser substituída completamente.
Problemas Difíceis em Reticulados
LWE — Learning With Errors
Dado $(A, b)$, encontrar $s$ — infeasível. Versão Module-LWE usa polinômios em $R_q = \mathbb{Z}_q[x]/(x^n+1)$, aumentando eficiência.
SIS — Short Integer Solution
Dado $A \in \mathbb{Z}_q^{m\times n}$, encontrar $z \neq 0$ com norma pequena — base das assinaturas ML-DSA e das provas de conhecimento zero em reticulados.
Módulo 1 — 07_quantum_sim
Simulador Quântico
Simula Grover e Shor classicamente para demonstrar a ameaça aos sistemas criptográficos atuais.
terminal
$ cd fhe/07_quantum_sim && GOWORK=off go run .
Estado Quântico: Formalismo
Um sistema de $n$ qubits possui $2^n$ estados base. O estado geral é uma superposição de amplitudes complexas:
Após $n=4$ qubits em superposição uniforme (porta Hadamard em todos): cada $\alpha_i = 1/4$, $P(i) = 6.25\%$ para todo $i \in \{0,\ldots,15\}$.
Algoritmo de Grover — Walkthrough: n=4, target=10
Grover busca um item em $N=2^n$ candidatos em $O(\sqrt{N})$ vs $O(N)$ classicamente. Número ótimo de iterações: $k = \lfloor \frac{\pi}{4}\sqrt{N} \rfloor = \lfloor \pi \rfloor = 3$.
Iteração 1 — Detalhado
Amps[10] → -0.25 (Oracle)
⟨α⟩ = 3.5/16 = 0.21875
Amps[10] = 2×0.219 + 0.25 = 0.6875
P(10) = 0.6875² ≈ 47.3%
Complexidade
Para AES-128: $2^{128} \to 2^{64}$ — por isso AES-256 é recomendado.
// grover.go — algoritmo completo
func Grover(n int, target int) int {
qs := NewQState(n)
qs.HAll() // superposição uniforme
N := 1 << n
iters := int(math.Round(math.Pi * math.Sqrt(float64(N)) / 4.0))
for iter := 0; iter < iters; iter++ {
oracle(qs, target) // inverte fase do alvo
diffuser(qs) // reflexão pela média
}
return qs.Measure()
}
// Difusor: H^n → flip fase de i>0 → H^n
func diffuser(qs *QState) {
qs.HAll()
for i := 1; i < len(qs.Amps); i++ {
qs.Amps[i] = -qs.Amps[i]
}
qs.HAll()
}Algoritmo de Shor — Fatorar N=15 com a=7
Shor fatoriza $N$ em $O((\log N)^3)$ — polinomial. RSA-2048 tem 2048 bits: GNFS clássico $\approx e^{64}$ operações vs Shor $\approx 2048^3 \approx 8.6 \times 10^9$.
Insight central: fatorar $N$ se reduz a encontrar o período de $f(x) = a^x \bmod N$.
| x | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| 7^x mod 15 | 1 | 7 | 4 | 13 | 1 | 7 | 4 | 13 | 1 |
Período $r = 4$ (marcado em roxo). A parte quântica (QFT) encontra $r$ eficientemente via picos de probabilidade em $j = k \cdot Q/r$.
// Redução clássica para fatores
r = 4 (par ✓), a^(r/2) = 7² = 49 ≡ 4 (mod 15)
4 ≢ -1 ≡ 14 (mod 15) ✓
p = gcd(4-1, 15) = gcd(3, 15) = 3 ✓
q = gcd(4+1, 15) = gcd(5, 15) = 5 ✓
15 = 3 × 5 ← RSA destruído em tempo polinomial
// shor.go — estrutura do algoritmo
func Shor(N int) (int, int) {
for attempt := 0; attempt < maxAttempts; attempt++ {
a := rand.Intn(N-2) + 2
if g := gcd(a, N); g > 1 { return g, N/g }
r := findPeriod(a, N) // usa DFT para simular QFT
if r%2 != 0 { continue }
halfPow := modPow(a, r/2, N)
if halfPow == N-1 { continue }
p, q := gcd(halfPow-1, N), gcd(halfPow+1, N)
if p > 1 && p < N { return p, q }
}
return 0, 0
}Módulo 2 — 08_pqc_stack
Stack PQC Completo
ML-KEM-768, ML-DSA-65 e Híbrido X25519 — padrões NIST FIPS 203/204 em Go com a biblioteca Cloudflare CIRCL.
Tamanhos e Comparativo
| Parâmetro | RSA-2048 | ECDH P-256 | ML-KEM-768 |
|---|---|---|---|
| Chave pública | 256 B | 65 B | 1184 B |
| Chave privada | 1232 B | 32 B | 2400 B |
| Ciphertext | 256 B | 65 B | 1088 B |
| Shared secret | 32 B | 32 B | 32 B |
| Segurança quântica | 0 bits | 0 bits | ~178 bits |
// mlkem.go — API circl v1.6.3
scheme := kyber768.Scheme()
pk, sk, _ := scheme.GenerateKeyPair()
// Encapsulação (terminal) — ct JÁ É []byte
ct, ss1, _ := scheme.Encapsulate(pk)
// Decapsulação (autoridade)
ss2, _ := scheme.Decapsulate(sk, ct)
fmt.Println("Match:", bytes.Equal(ss1, ss2)) // true1952 B
Chave pública
4032 B
Chave privada
3309 B
Assinatura
Nota da API circl v1.6.3: Sign retorna []byte, NÃO ([]byte, error). Use sig := scheme.Sign(sk, msg, nil)
// mldsa.go
scheme := mldsa65.Scheme()
pk, sk, _ := scheme.GenerateKeyPair()
// ATENÇÃO: Sign retorna []byte, não ([]byte, error)!
sig := scheme.Sign(sk, msg, nil)
ok := scheme.Verify(pk, msg, sig, nil)
fmt.Println("Verificação:", ok) // true
// Serialização: usar pk.MarshalBinary(), não scheme.MarshalBinaryPublicKey()
pkBytes, _ := pk.MarshalBinary() // 1952 bytesHíbrido X25519 + ML-KEM-768
Estratégia de transição: "se qualquer dos dois for seguro, o sistema é seguro." Signal, Chrome e AWS já usam esta abordagem.
Hoje (sem QC)
X25519 128-bit + ML-KEM 178-bit
QC 2030+ (Shor)
X25519 quebrado + ML-KEM 178-bit = OK
ML-KEM quebrado
X25519 128-bit = OK
Módulo 3 — 09_zkp_pqc
ZKP em Reticulados — Schnorr Lattice
Prova de conhecimento zero baseada em SIS: sem curvas elípticas, resistente a Shor.
Schnorr Clássico P-256 — VULNERÁVEL
Prova conhecimento de $x$ tal que $Y = x \cdot G$ em curva elíptica.
W = k·G (commit)
c = H(W || Y || msg) (desafio)
s = k + c·x (resposta)
Verifica: s·G = W + c·Y
Shor resolve log discreto em P-256 → protocolo destruído
Schnorr Lattice — SEGURO
Prova conhecimento de $s$ tal que $A \cdot s = t \pmod{q}$ em reticulado.
w = A·y mod q (commit)
c = H(w || t || msg) (desafio)
z = y + c·s (resposta)
Verifica: A·z = w + c·t mod q
SIS: encontrar z pequeno com Az=0 é infeasível quantum-classicamente
Parâmetros Toy (educacionais)
// lattice.go — parâmetros toy (ML-DSA real: q=8380417, n=256)
const (
q = 251 // módulo primo
n = 8 // dimensão do polinômio
m = 4 // número de linhas em A
eta = 2 // limite coef. chave secreta |sᵢ| ≤ η
gam = 30 // limite coef. randomness |yᵢ| ≤ γ
beta = 40 // β = γ + maxC·η = 30 + 5·2 = 40
)Walkthrough Numérico (m=1, n=4)
// KEYGEN
A = [142, 87, 203, 11]
s = [1, -2, 0, 1] // |sᵢ| ≤ 2
t = 142·1 + 87·(-2) + 203·0 + 11·1 mod 251 = -21 mod 251 = 230
// PROVA
y = [28, -15, 7, -3] // |yᵢ| ≤ 30
w = 142·28 + 87·(-15) + 203·7 + 11·(-3) mod 251 = 4059 mod 251 = 43
c = H(43, 230, msg) = 3
z = [28+3·1, -15+3·(-2), 7+3·0, -3+3·1] = [31, -21, 7, 0]
‖z‖∞ = 31 ≤ 40 = β ✓ (rejection sampling OK)
// VERIFICAÇÃO
A·z mod 251 = 142·31 + 87·(-21) + 203·7 + 11·0 mod 251 = 3996 mod 251 = 231
w + c·t mod 251 = 43 + 3·230 mod 251 = 733 mod 251 = 231
✓ A·z = w + c·t — ACEITAR
ZKP de Voto One-Hot
O eleitor prova que seu voto é one-hot (exatamente um candidato) sem revelar qual. Usa commitments baseados em reticulados: $t_i = A \cdot r_i + v_i \cdot g \pmod{q}$.
// Voto no candidato 2 de 4:
t₁ = A·r₁ + 0·g = A·r₁
t₂ = A·r₂ + 1·g = A·r₂ + g ← candidato escolhido
t₃ = A·r₃ + 0·g = A·r₃
t₄ = A·r₄ + 0·g = A·r₄
// Σtᵢ = A·(Σrᵢ) + 1·g = commit(1, R)
// Schnorr proof de conhecimento de R: A·R = Σtᵢ - g
Propriedade homomórfica: $\sum t_i = A(\sum r_i) + 1 \cdot g$. Verificador confirma integridade sem saber qual $t_i$ corresponde ao voto.
Módulo 4 — 10_starkproof
STARK — Provas Escaláveis Quantum-Safe
STARKs usam apenas SHA-256 — sem curvas elípticas, sem trusted setup, naturalmente resistentes a computadores quânticos.
Apenas SHA-256
Sem grupos de curvas elípticas. Grover reduz SHA-256 para 128-bit — ainda seguro.
Sem Trusted Setup
SNARKs precisam de pairings (vulneráveis a Shor). STARKs não — transparência total.
~2.5 KB de prova
Verificação em $O(\log^2 n)$ vs $O(n)$ do prover. Auditável por qualquer um.
Campo Finito $\mathbb{Z}_{65537}$
$P = 65537 = 2^{16}+1$ é o quinto primo de Fermat. $P-1 = 2^{16}$ é potência pura de 2 — essencial para FFT sobre campos finitos e para o protocolo FRI.
// field.go
const (
P = 65537 // 2^16 + 1 (Fermat prime)
G = 3 // raiz primitiva: ord(3) = 65536
)
func fadd(a, b int) int { return (a + b) % P }
func fmul(a, b int) int { return (a * b) % P }
func finv(a int) int { return fpow(a, P-2, P) }
// Raiz de unidade de ordem n:
// w = 3^(65536/n) mod 65537
func rootOfUnity(n int) int {
return fpow(G, (P-1)/n, P)
}Exemplo: raiz de unidade de ordem 8
w = 3^(65536/8) mod 65537
= 3^8192 mod 65537 = 4096
Verificar: 4096^8 mod 65537 = 1 ✓
pois $4096 = 2^{12}$, $4096^8 = 2^{96} = 2^{16\times6} \equiv (-1)^6 = 1 \pmod{P}$
Árvore Merkle SHA-256 (Comprometimento)
nodes[1] ← raiz (comprometimento)
/ \
nodes[2] nodes[3]
/ \ / \
nodes[4] nodes[5] nodes[6] nodes[7]
| | | |
v₀=5 v₁=26 v₂=677 v₃=654 ← trace values
Cada folha é $\text{SHA-256}(v_i)$, cada nó interno é $\text{SHA-256}(\text{esq} \mathbin{\|} \text{dir})$. Prova de inclusão: $O(\log n)$ siblings.
Protocolo FRI — Dobramento Iterativo
FRI prova que um polinômio tem grau baixo, sem revelar seus coeficientes. Cada round dobra o grau:
O desafio $r$ é derivado do hash Merkle (Fiat-Shamir). Após $k$ rounds, o polinômio é quase constante — prova de baixo grau.
STARK Completo: f(y) = y² + 1, secretX=5, 4 passos
| Passo | Cálculo | Valor |
|---|---|---|
| T[0] | secretX (privado) | 5 |
| T[1] | 5² + 1 | 26 |
| T[2] | 26² + 1 | 677 |
| T[3] | 677² + 1 mod 65537 | 654 |
| T[4] | 654² + 1 mod 65537 | 52968 |
publicOut = 52968 (público) — o verificador confirma que o prover conhece algum $x$ tal que $f^4(x) = 52968 \pmod{65537}$, sem aprender que x=5.
// stark.go
const (
STEPS = 4 // iterações da função f
TRACE_N = 8 // domínio de trace (≥ STEPS+1, potência de 2)
LDE_N = 32 // domínio LDE (blowup 4x para solidez)
N_QUERY = 3 // spot-checks: prob. fraude ≤ (32/65537)³ ≈ 10⁻¹¹
)
func buildTrace(secretX int) []int {
trace := make([]int, TRACE_N)
trace[0] = secretX
for i := 1; i <= STEPS; i++ {
p := trace[i-1]
trace[i] = (fmul(p, p) + 1) % P // f(y) = y² + 1
}
return trace
}Módulo 5 — 10_kyber_fhe_bridge
Bridge ML-KEM + FHE
Sistema completo de votação eletrônica: canal quantum-safe (ML-KEM-768 + AES-GCM) + computação homomórfica (BGV).
Diagrama do Sistema
SERVIDOR TERMINAL
────────────────────────────────────────────────────
NewBridgeServer()
├─ BGV: LogN=12, LogQ=[38,40], t=65537
│ → pk_FHE (~196 KB), sk_FHE
└─ ML-KEM-768 keygen
→ pk_KEM (1184B), sk_KEM (2400B)
Publica pk_KEM ──────────────────→ encapsula: ct_KEM (1088B), ss (32B)
Decapsula ct_KEM ←─────────── envia ct_KEM
→ ss (32B) [mesmo que terminal]
→ AES-GCM(key=ss, pk_FHE)
enc_pk_FHE ──────────────────────→ AES-GCM decrypt(ss)
→ pk_FHE
BGV_Enc(pk_FHE, [1,0,0,...])
→ ct_fhe (~131 KB)
Recebe ct_fhe ←──────────────────── envia ct_fhe
Soma homomórfica (sem decriptar!):
sum = AddNew(ct_A, ct_B)
sum = AddNew(sum, ct_C)
result = Decrypt(sk_FHE, sum)
→ [Alice:2, Bob:1, Carlos:0]
Parâmetros BGV (Lattigo v6)
// fhe_engine.go
var BGVParamsLiteral = bgv.ParametersLiteral{
LogN: 12, // N = 2^12 = 4096 slots SIMD
LogQ: []int{38, 40}, // q ≈ 2^78 (2 níveis: 1 multiplicação)
LogP: []int{40}, // auxiliar para key switching
PlaintextModulus: 65537, // t = 2^16+1 (primo Fermat, ideal NTT)
}
// NOTA: Lattigo v6 usa LogQ/LogP (bits), não Q/P (primos explícitos) da v5Bug Corrigido: Aritmética Modular com uint64
// BUG: int(uint64(big)) % n pode ser NEGATIVO em Go!
// In Go, % preserves sign of dividend. int(0xFF...F) = -1, (-1)%n = -1
// ERRADO:
idx := int(binary.BigEndian.Uint64(hash[:])) % n
// CORRETO: módulo antes de converter
idx := int(binary.BigEndian.Uint64(hash[:]) % uint64(n))Saída Real da Execução
=== Bridge ML-KEM-768 + BGV/FHE ===
terminal-A: shared secret = 69f056065e74b5f0… [match=true]
terminal-A: voto=0 encriptado → 131406 bytes (FHE ct)
terminal-B: voto=0 encriptado → 131406 bytes (FHE ct)
terminal-C: voto=1 encriptado → 131406 bytes (FHE ct)
Soma homomorfica em 1ms
Alice: 2 votos, Bob: 1 votos, Carlos: 0 votos, Total: 3 votos
Análise de Segurança da Bridge
| Camada | Algoritmo | Base de Segurança | Quantum-Safe? |
|---|---|---|---|
| Troca de chave | ML-KEM-768 | Module-LWE | SIM |
| Transporte pk_FHE | AES-GCM-256 | Busca exaustiva | SIM |
| Encriptação de voto | BGV/RLWE | Ring-LWE | SIM |
| Comprometimento | SHA-256 | Colisão/preimagem | SIM |
⚠ Urgência 2029
CRQC Timeline — A Janela Está Fechando
Baseado em: Filippo Valsorda — "CRQC Timeline" — engenheiro de criptografia, ex-Go team/Google, autor do age.
Prazo anterior
2035
Estimativa até Jan/2025
Prazo revisado
2029
Google + Oratomic confirmam
Hoje: 2026-04-06
1000
dias até Jan/2029
O Que Mudou em Jan/2025
Google Research
Curvas elípticas P-256 e secp256k1 de 256 bits podem ser quebradas em minutos usando qubits supercondutores — com muito menos qubits lógicos do que se estimava anteriormente.
Heather Adkins + Sophie Schmieg: "fronteiras quânticas podem estar mais próximas do que parecem"
Oratomic — Átomos Neutros
Demonstração de que P-256 pode ser quebrado com apenas ~10.000 qubits físicos usando átomos neutros — mais lento, mas igualmente catastrófico.
Scott Aaronson: "comparo este momento ao período em que pesquisas de fissão nuclear foram classificadas (1939–40)"
Harvest Now, Decrypt Later (HNDL)
A ameaça não espera 2029. Adversários estatais já coletam tráfego cifrado com ECDH. Quando o CRQC existir, decriptam tudo retroativamente.
2026 — Hoje
TLS ECDHE capturado
{pub_Bob, ct_AES}
Adversário armazena
2029 — CRQC
Shor(pub_Bob)
→ priv_Bob
Em minutos
Resultado
ECDH(priv_Bob, pub_alice)
→ shared_secret
Mensagem decriptada
// Módulo 11 — demo real (GOWORK=off go run ./fhe/11_crqc_migration)
2029 — Mensagem decriptada: "CONFIDENCIAL: chave mestra sistema bancário — validade 2028-12-31"
Checklist: Agir Agora vs Pode Esperar
🔴 Agir Agora
HTTPS / TLS 1.3
ECDHE → ML-KEM-768 hybrid. HNDL ativo: sessões hoje decriptadas em 2029.
SSH Host Keys
ECDSA/Ed25519 → ML-DSA-65. Chaves de longo prazo críticas.
Certificados TLS
Emitir novos certs com ML-DSA-65. Certs atuais expiram 2027–2029.
Bluesky / atproto DIDs
secp256k1 → ML-DSA. Identidades permanentes explicitamente citadas por Filippo.
Bitcoin P2PK UTXOs
ECDSA secp256k1 — chave pública diretamente exposta. Requer hard fork.
✅ Simétrico Seguro — Não Migrar
AES-256-GCM
Grover: 2^128 efetivo. Nenhuma ação necessária.
SHA-256 / SHA-3 / HMAC
Grover: colisão em 2^128. Seguro para longo prazo.
🟠 Reavaliar em 2026–2027
JWT ES256 / JOSE
Tokens longa duração = risco. Draft JOSE PQC em desenvolvimento.
age (encrypt files)
X25519 recipient → ML-KEM-768. Citado pelo próprio Filippo.
Intel SGX / AMD SEV-SNP
Sem raízes PQC → attestation não confiável após CRQC.
Comparativo de Tamanhos — Saída do Módulo 11
Troca de Chaves (KEM)
| Campo | ECDH P-256 | ML-KEM-768 |
|---|---|---|
| Chave pública | 65 B | 1 184 B |
| Chave privada | 32 B | 2 400 B |
| Ciphertext | — | 1 088 B |
| Shared secret | 32 B | 32 B |
| CRQC 2029 | ❌ Quebrado | ✓ Seguro |
FIPS 203 — Module-LWE (tempo: ~160µs)
Assinatura Digital
| Campo | ECDSA P-256 | ML-DSA-65 |
|---|---|---|
| Chave pública | 65 B | 1 952 B |
| Chave privada | 32 B | 4 032 B |
| Assinatura | 71 B | 3 309 B |
| Verify adulterado | — | false ✓ |
| CRQC 2029 | ❌ Quebrado | ✓ Seguro |
FIPS 204 — Module-LWE+SIS (tempo: ~750µs)
Timeline Revisada
NIST FIPS 203/204/205 publicados — ML-KEM, ML-DSA, SLH-DSA padronizados
Google: P-256 quebrado em minutos com supercondutores (menos qubits que o previsto)
Oratomic: P-256 quebrado com ~10.000 qubits físicos de átomos neutros
Filippo Valsorda: "mudei minha visão — prazo crítico é 2029, não 2035" — words.filippo.io/crqc-timeline/
← Você está aqui — janela de migração: ~1000 dias
Deadline prático: certificados TLS emitidos agora devem ser PQC (validade 2 anos)
Última chance: sistemas sem PQC já comprometidos por HNDL acumulado
CRQC estimado — ECDH P-256, RSA-2048, secp256k1 potencialmente quebráveis
Sistemas migrados para ML-KEM + ML-DSA + BGV/FHE permanecem seguros indefinidamente
Módulo 11 — CRQC Migration Demo
cd fhe/11_crqc_migration
GOWORK=off go run .
# Saída esperada:
# ⚠️ CRQC estimado: Jan/2029 — 1000 dias restantes
# [1] HNDL: "CONFIDENCIAL: chave mestra..." decriptada em 2029
# [2] ML-KEM-768: pk=1184B, sk=2400B, ct=1088B, ss=32B ✓
# [3] ML-DSA-65: pk=1952B, sk=4032B, sig=3309B, verify=true ✓
# [4] 13 protocolos analisados: TLS, SSH, JWT, age, Bitcoin...
# [5] Timeline: 2024-08 NIST → 2025-01 Google/Oratomic → 2029-01 CRQC
Referências
Filippo Valsorda — CRQC Timeline
words.filippo.io/crqc-timeline/
NIST FIPS 203 — ML-KEM
doi.org/10.6028/NIST.FIPS.203
NIST FIPS 204 — ML-DSA
doi.org/10.6028/NIST.FIPS.204
NIST FIPS 205 — SLH-DSA
doi.org/10.6028/NIST.FIPS.205
Cloudflare CIRCL
github.com/cloudflare/circl — ML-KEM + ML-DSA em Go
Lattigo v6 — BGV/FHE
github.com/tuneinsight/lattigo
Aplicações
20 Aplicações FHE + PQC
Casos de uso reais para o stack quântico-seguro — de votação eletrônica à análise genômica privada.
🗳️ Votação Eletrônica Quântico-Segura
Terminais encriptam votos com BGV, autoridade soma homomorficamente sem ver os votos individuais. Canal ML-KEM protege a troca de chaves contra Shor em 2030+.
Módulo 10_kyber_fhe_bridge — saída: Alice:2, Bob:1, Carlos:0
🔬 Diagnóstico Médico com FHE
Hospital processa dados de paciente cifrados com CKKS. Resultado do diagnóstico retorna sem expor genoma ou prontuário. Compliant com LGPD/HIPAA.
CKKS para ponto flutuante — precisão configurável por escala Δ
🏦 Conformidade Bancária PQC
Bancos calculam exposição regulatória em dados cifrados de clientes sem decifrar. Canal ML-KEM protege a transmissão, BGV processa os dados homomorficamente.
sharedSecret = SHA-256(ss_X25519 || ss_MLKEM) para transição gradual
🔐 Assinatura de Código Quantum-Safe
ML-DSA-65 substitui ECDSA em pipelines CI/CD. Binários assinados resistem a computadores quânticos. Assinatura: 3309 B vs 64 B do ECDSA — maior, porém seguro.
sig := scheme.Sign(sk, msg, nil) — FIPS 204, Nível 3
🗝️ Prova Zero-Knowledge de Voto
Votante prova one-hot sem revelar candidato. Lattice Schnorr: A·z = w + c·t mod q. Resistente a Shor, sem curvas elípticas.
Módulo 09_zkp_pqc — parâmetros: q=251, n=8, β=40
🏛️ PKI Governamental PQC
ML-KEM-768 para TLS 1.3 + ML-DSA-65 para certificados digitais. Substituição de RSA-2048 em infraestrutura crítica nacional. NIST FIPS 203/204.
pk_KEM=1184B, sk_KEM=2400B, pk_DSA=1952B, sk_DSA=4032B
🧬 Análise Genômica Privada
Laboratório busca marcadores BRCA1/APOE4 em sequência genômica cifrada do paciente com CKKS. Zero exposição de DNA — resultado sem decriptar.
CKKS: encode(z) = ⌊Δ · iDFT(z)⌋, Δ = 2^45, N/2 slots complexos
📊 Auditoria Fiscal Homomórfica
Receita Federal verifica conformidade de declarações sem acesso aos dados brutos dos contribuintes. BGV processa os registros cifrados, prova conformidade via FHE.
Enc(m₁) + Enc(m₂) = Enc(m₁+m₂ mod t) — adição exata em Z_t
🌐 Identidade Digital com STARKs
Provar "tenho mais de 18 anos" sem revelar data de nascimento. Prova hash-only de 2.5 KB, sem trusted setup, verificação em O(log² n).
SHA-256 only: resistente a Grover (128-bit efetivo) e a Shor
🔑 Hybrid KEM para TLS Quântico
X25519 + ML-KEM-768: seguro mesmo que um dos dois seja quebrado. Estratégia adotada por Signal, Chrome e AWS durante a transição para PQC.
sharedSecret = SHA-256(ss_X25519 || ss_MLKEM) — 32 bytes
🏗️ Smart Contracts com FHE
Contratos Ethereum calculam sobre estado cifrado. Leilões cegos — proposta mais alta sem revelar valor até o encerramento. Votação DAO sem expor votos individuais.
BGV: SIMD sobre 4096 slots, cada operação processa em paralelo
💊 Pesquisa Clínica Multi-Hospitalar
10 hospitais contribuem dados de pacientes cifrados com BGV. Pesquisador obtém estatísticas agregadas sem ver dados individuais. Compliant com LGPD.
Σ Enc(vᵢ) = Enc(Σvᵢ) — soma homomórfica sem decriptar intermediários
🔒 Zero-Knowledge para KYC
Provar "meu CPF está na lista aprovada" sem revelar o CPF. Private Set Intersection com FHE + Lattice ZKP — compliance sem exposição de dados pessoais.
SIS: encontrar z com Az=0 mod q e ‖z‖ pequena — infeasível quanticamente
⚛️ Busca Quântica em Grafos
Grover aplicado a busca em grafos de rotas: O(√N) vs O(N) clássico. Para N=16: 3 iterações, 96.1% de probabilidade. Para N=1024: 25 iterações.
k_opt = ⌊(π/4)·√N⌋ — para N=1024: k=25, complexidade O(32) vs O(1024)
🛡️ HSM Pós-Quântico
ML-KEM-768 + ML-DSA-65 em módulo de hardware seguro. Chaves geradas e assinaturas realizadas dentro do HSM — jamais expostas em memória principal.
sk_KEM=2400B, sk_DSA=4032B — tamanhos maiores que ECDH mas quantum-safe
📡 IoT com Canal Quantum-Safe
ML-KEM-768 para estabelecer canal em dispositivos IoT com pouca memória. pk de 1184B é viável em microcontroladores ARM. AES-GCM-256 para payload.
ct_KEM=1088B, ss=32B → AES-256 key — overhead mínimo pós-handshake
🏥 Prontuário Eletrônico Federado
Múltiplos hospitais treinam modelo de ML sobre prontuários cifrados com FHE federated. Sem centralizar dados sensíveis — gradientes calculados homomorficamente.
CKKS para ML: ponto flutuante com rescaling automático após multiplicação
✅ Verificação de Integridade STARK
Provar que código/dados não foram adulterados com prova de 2.5KB baseada em SHA-256. Auditável publicamente — qualquer um pode verificar sem trusted setup.
Prob. fraude ≤ (LDE_N/P)^N_QUERY = (32/65537)³ ≈ 10⁻¹¹
💼 Supply Chain com ZKP
Fornecedor prova "tenho certificação ISO" sem revelar detalhes do audit. Prova não-interativa via Fiat-Shamir. Lattice ZKP resistente a computadores quânticos.
c = H(w || t || msg) — Fiat-Shamir transforma protocolo interativo em NI-ZKP
🔮 Migração de Legados para PQC
Estratégia híbrida durante a transição: sistemas legados mantêm RSA/ECDH, novos sistemas usam ML-KEM/ML-DSA. "Harvest now, decrypt later" — migração urgente mesmo sem QC hoje.
Timeline: 2024 (NIST FIPS) → 2026 (migração urgente) → 2030 (Q-Day estimado) → 2035 (RSA deprecated)
Análise Comparativa
Segurança Comparativa
| Primitiva | Shor? | Grover? | NIST PQC | Módulo |
|---|---|---|---|---|
| RSA-2048/4096 | SIM | — | Não | — |
| ECDH P-256 | SIM | — | Não | — |
| ECDSA / EdDSA | SIM | — | Não | — |
| Schnorr P-256 | SIM | — | Não | 09 (demo vulnerável) |
| AES-128 | Não | 64-bit efet. | Marginal | — |
| AES-256 | Não | 128-bit efet. | Sim | 10_bridge |
| SHA-256 | Não | 128-bit | Sim | todos |
| ML-KEM-768 | Não (M-LWE) | ~168-bit | FIPS 203 | 08, 10 |
| ML-DSA-65 | Não (M-LWE) | ~165-bit | FIPS 204 | 08 |
| BGV / RLWE | Não (RLWE) | ~128-bit | — | 10_bridge |
| STARKs (SHA-256) | Não | 128-bit efet. | — | 10_stark |
| Schnorr Lattice | Não (SIS) | Leve | Base FIPS 204 | 09 |
Timeline da Ameaça Quântica
Tamanhos de Dados no Sistema de Votação
ML-KEM-768
pk: 1184 B
sk: 2400 B
ct: 1088 B
ss: 32 B
ML-DSA-65
pk: 1952 B
sk: 4032 B
sig: 3309 B
BGV/FHE
pk_FHE: ~196 KB
ct_FHE: ~131 KB
STARK: ~2.5 KB