Cryptography on kenji.blog

Fundamentos e Implementação da Criptografia usando o Pequeno Teorema de Fermat

Fri, 11 Sep 2026 22:00:00 +0900

1. Introdução: O mistério matemático que sustenta a criptografia moderna

Na sociedade digital moderna, especialmente nas comunicações via Internet, a “criptografia” tornou-se uma tecnologia fundamental indispensável. O fato de podermos navegar na web de forma segura via HTTPS em nossos navegadores, realizar transações financeiras no internet banking e trocar mensagens privadas em aplicativos de mensagens é possível devido aos protocolos criptográficos apoiados por teorias matemáticas avançadas que operam nos bastidores. Entre eles, o sistema de “criptografia de chave pública” desempenha um papel particularmente importante, e seu principal representante é a Criptografia RSA.

A segurança e a validade de muitos algoritmos criptográficos, incluindo o RSA, dependem fortemente de um teorema muito belo e poderoso descoberto pelo matemático francês do século 17, Pierre de Fermat. Esse é o Pequeno Teorema de Fermat (Fermat’s Little Theorem). Além disso, o teorema de Leonhard Euler, que generaliza isso, também desempenha um papel decisivo na teoria da criptografia.

Neste artigo, explicaremos detalhadamente desde o básico como a descoberta do Pequeno Teorema de Fermat, na matemática pura, é aplicada às tecnologias de criptografia práticas modernas, em particular ao “teste de primalidade” e à “criptografia RSA”. Este será um guia técnico muito detalhado que cobre provas matemáticas, os mecanismos de criptografia e descriptografia, e implementações de algoritmos específicos em C++ e Python.

2. Fundamentos de Congruências e Aritmética Modular

Para entender o Pequeno Teorema de Fermat, primeiro precisamos nos familiarizar com o conceito matemático de “aritmética modular (congruências)”. A aritmética modular é um sistema de cálculo que foca no “resto” quando dividido por um número fixo (chamado de módulo). Por ser um cálculo parecido com o mostrador de um relógio (que dá uma volta em 12 horas), também é chamada de “matemática do relógio”.

Quando o resto da divisão dos inteiros $a$ e $b$ por um inteiro positivo $n$ é igual, matematicamente, descrevemos da seguinte forma:

$$ a \equiv b \pmod n $$

Isso é lido como “$a$ e $b$ são congruentes módulo $n$”. Por exemplo, o resto da divisão de 17 por 5 é 2, e o resto da divisão de 12 por 5 também é 2. Portanto, podemos escrever:

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

Na aritmética modular, as quatro operações aritméticas normais (adição, subtração e multiplicação) valem como são:

Adição: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a + c \equiv b + d \pmod n$
Subtração: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a - c \equiv b - d \pmod n$
Multiplicação: Se $a \equiv b \pmod n$ e $c \equiv d \pmod n$, então $a \times c \equiv b \times d \pmod n$
Exponenciação: Se $a \equiv b \pmod n$, então para qualquer número natural $k$, $a^k \equiv b^k \pmod n$

No entanto, é necessário ter cuidado com a divisão. Em geral, o fato de que $a \times c \equiv b \times c \pmod n$ não significa que podemos dividir ambos os lados por $c$ para obter $a \equiv b \pmod n$. Isso só é verdadeiro se $c$ e $n$ forem coprimos (o máximo divisor comum for 1). Esse conceito de “inverso modular” torna-se extremamente importante na geração de chaves da criptografia RSA descrita mais adiante.

3. Fundamentação Matemática e Prova do Pequeno Teorema de Fermat

Agora que entendemos os fundamentos da aritmética modular, vamos analisar o assunto principal: o Pequeno Teorema de Fermat.

3.1 Definição do Teorema

O Pequeno Teorema de Fermat é formulado da seguinte maneira:

Pequeno Teorema de Fermat (Fermat’s Little Theorem) Seja $p$ um número primo e $a$ um número inteiro que não seja um múltiplo de $p$ (ou seja, $a$ e $p$ são coprimos). Então, a seguinte congruência é válida:
$$ a^{p-1} \equiv 1 \pmod p $$

Também é comum expressá-lo de uma forma que seja válida para todos os inteiros $a$, removendo a condição “se $a$ não for múltiplo de $p$”. Nesse caso, multiplicando ambos os lados por $a$, temos:

$$ a^p \equiv a \pmod p $$

3.2 Confirmação com Exemplos Específicos

Vamos confirmar se o teorema é realmente válido usando números específicos. Seja o número primo $p = 5$. Então $p-1 = 4$. Escolheremos um número inteiro $a$ que não seja um múltiplo de $p$.

Para $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ com resto $1$. Portanto, $16 \equiv 1 \pmod 5$. (Válido)
Para $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ com resto $1$. Portanto, $81 \equiv 1 \pmod 5$. (Válido)
Para $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ com resto $1$. Portanto, $256 \equiv 1 \pmod 5$. (Válido)

Como podemos ver, qualquer $a$ que escolhermos (desde que não seja um múltiplo de 5), o resto após elevá-lo à quarta potência e dividi-lo por 5 será sempre 1. Parece magia, mas isso se origina das belas propriedades que os números primos possuem.

3.3 Prova Matemática do Teorema

Por que isso acontece? Aqui apresentamos uma prova elegante usando conjuntos de classes de resíduos.

Considere o conjunto $S = \{1, 2, 3, \dots, p-1\}$. Estes são os representantes dos números inteiros cujos restos da divisão por $p$ são de $1$ a $p-1$. Agora, considere um novo conjunto $T$, formado pela multiplicação de cada elemento por um inteiro $a$, coprimo com $p$.

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

Vamos considerar o resto de cada elemento desse conjunto $T$ quando dividido por $p$. Surpreendentemente, esses restos, embora a ordem possa mudar, coincidem perfeitamente com o conjunto de elementos do conjunto original $S$. Por que:

Nenhum elemento de $T$ será múltiplo de $p$ (porque nem $a$ nem os elementos originais são múltiplos de $p$).
Não existem dois elementos diferentes em $T$ que sejam congruentes módulo $p$. Se houvesse $ia \equiv ja \pmod p$ ($i \neq j$), já que $a$ e $p$ são coprimos, poderíamos dividir por $a$ e obter $i \equiv j \pmod p$, o que é uma contradição.

Portanto, o produto de todos os elementos de $S$ e o produto de todos os elementos de $T$ são congruentes módulo $p$.

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

Organizando o lado esquerdo, como temos $p-1$ fatores $a$, obtemos:

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

Como $(p-1)!$ e $p$ são coprimos, podemos dividir ambos os lados por $(p-1)!$, o que nos leva finalmente ao seguinte teorema:

$$ a^{p-1} \equiv 1 \pmod p $$

Esta é a prova do Pequeno Teorema de Fermat.

4. A Função Totiente de Euler e o Teorema de Euler

O Pequeno Teorema de Fermat é um teorema sobre um “número primo $p$”, mas quem o generalizou para “qualquer inteiro positivo $n$” foi Leonhard Euler. Essa extensão é essencial para compreender a criptografia RSA.

4.1 Função Totiente de Euler $\phi(n)$

A função totiente de Euler (ou função $\phi$ de Euler) $\phi(n)$ é uma função que representa “a quantidade de inteiros de $1$ a $n$ que são coprimos com $n$”.

Para um número primo $p$, como todos os inteiros de $1$ a $p-1$ são coprimos com $p$, temos $\phi(p) = p - 1$.
Para dois números primos distintos $p$ e $q$, o valor de $\phi(n)$ para o seu produto $n = p \times q$ pode ser calculado com uma fórmula muito simples: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Esta propriedade é a lógica central na geração de chaves da criptografia RSA.

4.2 Teorema de Euler

Euler generalizou o Pequeno Teorema de Fermat da seguinte maneira:

Teorema de Euler (Euler’s Theorem) Para qualquer inteiro positivo $n$ e um inteiro $a$ coprimo com ele, é válido que:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Se $n$ for um número primo $p$, então $\phi(p) = p - 1$, o que o torna exatamente o Pequeno Teorema de Fermat ($a^{p-1} \equiv 1 \pmod p$). Em outras palavras, o Pequeno Teorema de Fermat não passa de um caso especial do Teorema de Euler.

5. Encontrando Números Primos Gigantescos: O Teste de Primalidade de Fermat

Na tecnologia criptográfica (como a criptografia RSA e a troca de chaves Diffie-Hellman), é necessário encontrar “números primos gigantescos” de centenas de dígitos em alta velocidade. No entanto, para testar se um número gigante $N$ é primo através da “divisão por tentativa” (testando a divisibilidade por todos os números de $2$ a $\sqrt{N}$), levaria tanto tempo quanto a idade do universo.

Aqui entra o Teste de Primalidade de Fermat (Fermat Primality Test), um “teste de primalidade probabilístico” que usa o Pequeno Teorema de Fermat.

5.1 O que é um Teste de Primalidade Probabilístico?

De acordo com o Pequeno Teorema de Fermat, se $p$ for um número primo, então, para qualquer $a$ ($1 < a < p$), $a^{p-1} \equiv 1 \pmod p$ é sempre válido. Tomando a contrapositiva: “Se houver algum $a$ para o qual $a^{p-1} \not\equiv 1 \pmod p$, então $p$ absolutamente não é um número primo (é um número composto)”.

Portanto, se quisermos testar se $N$ é um número primo, escolhemos aleatoriamente alguns valores para $a$, calculamos $a^{N-1} \pmod N$ e verificamos se o resultado é $1$. Se obtivermos uma resposta diferente de $1$ mesmo que seja apenas uma vez, concluímos que $N$ é um número composto. Se o resultado for sempre $1$, independentemente de quantas vezes testarmos, podemos julgar com alta probabilidade que $N$ “provavelmente é primo”.

5.2 Explicação do Algoritmo e Fluxograma

O algoritmo do teste de Fermat é o seguinte.

flowchart TD Start["Início"] --> Input["Inserir o número a testar p e o número de testes k"] Input --> LoopStart["Loop de i = 0 até k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Sim" --> RandomA["Escolher um inteiro aleatório a no intervalo 1 < a < p-1"] RandomA --> Calc["Calcular a exponenciação modular a^(p-1) mod p"] Calc --> CheckPrime{"O resultado é 1 ?"} CheckPrime -- "Não" --> ReturnComposite["p é um número composto (Definitivo)"] CheckPrime -- "Sim" --> Increment["Incrementar i"] Increment --> Condition Condition -- "Não" --> ReturnPrime["p é provavelmente primo (Probabilístico)"] ReturnComposite --> End["Fim"] ReturnPrime --> End

5.3 A Armadilha dos Números de Carmichael (Pseudoprimos)

O teste de Fermat é extremamente rápido, mas tem uma desvantagem séria. Existem números maldosos que, apesar de serem compostos, satisfazem $a^{N-1} \equiv 1 \pmod N$ para todos os valores de $a$. Estes são chamados de Números de Carmichael (Carmichael numbers). O menor número de Carmichael é $561$ ($3 \times 11 \times 17$).

Devido à existência dos números de Carmichael, não se pode realizar um teste de primalidade absoluto usando apenas o teste puro de Fermat. Por esta razão, em sistemas criptográficos reais (como o OpenSSL), o Teste de Primalidade de Miller-Rabin, que é um aprimoramento do teste de Fermat, é usado como padrão. O teste de Miller-Rabin consegue detectar os números de Carmichael, reduzindo a probabilidade de falso julgamento praticamente a zero.

5.4 Exponenciação Modular Rápida (Método de Exponenciação Binária)

No algoritmo de teste de primalidade, precisamos calcular $a^{N-1} \pmod N$, mas se $N$ for enorme, $a^{N-1}$ terá uma quantidade astronômica de dígitos e não caberá na memória do computador. O que resolve esse problema é a Exponenciação Binária (Exponentiation by Squaring) ou exponenciação modular. Ao aplicar o módulo (mod N) a cada etapa do cálculo, o valor é mantido sempre inferior a $N$, permitindo um cálculo muito rápido (complexidade $O(\log N)$).

6. Implementação do Teste de Primalidade e Exponenciação Modular

Agora, vamos implementar o teste de primalidade de Fermat e o método de exponenciação binária em C++ e Python.

6.1 Implementação em C++

Em C++, os tipos de inteiros padrão tendem a transbordar, exigindo bibliotecas de inteiros de precisão arbitrária (como GMP) para lidar com números enormes, mas aqui mostramos uma implementação dentro do limite de um inteiro de 64 bits (unsigned long long) para entender o algoritmo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// Exponenciação modular rápida (a^b mod m) - Método de exponenciação binária
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Se o bit menos significativo de b for 1, multiplica o resultado por a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Extensão para 128 bits para evitar transbordamento
 }
 // Eleva a ao quadrado
 a = (__int128)a * a % m;
 // Desloca b para a direita (divide por 2)
 b /= 2;
 }
 return result;
}

// Teste de primalidade de Fermat
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Se a^(p-1) mod p não for 1, é um número composto
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Provavelmente primo
}

int main() {
 unsigned long long num = 1000000007; // Número primo conhecido
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Implementação em Python

O tipo inteiro padrão do Python suporta precisão arbitrária nativamente, de modo que não há necessidade de se preocupar com estouro de dígitos. Além disso, a função interna do Python pow(a, b, m) usa internamente o método de exponenciação binária, tornando-a muito rápida.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 Teste de primalidade probabilístico usando o Teste de Primalidade de Fermat
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Escolhe um número aleatório a entre 2 e p-2
 a = random.randint(2, p - 2)
 # Calcula a^(p-1) mod p. A função interna pow é rápida.
 if pow(a, p - 1, p) != 1:
 return False # Definitivamente composto

 return True # Provavelmente primo

# Teste
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} é provavelmente primo.")
else:
 print(f"{number_to_test} é composto.")

7. Aplicação na Criptografia RSA: Onde Fermat e Euler dão Frutos

A maior aplicação do Pequeno Teorema de Fermat (e do Teorema de Euler) é a Criptografia RSA, desenvolvida por Rivest, Shamir e Adleman em 1977. A criptografia RSA é um sistema revolucionário de “criptografia de chave pública”, que consegue um mecanismo onde a chave para criptografar (a chave pública) é revelada a todo o mundo, enquanto a chave para descriptografar (a chave privada) é conhecida apenas pelo destinatário pretendido.

Essa assimetria é baseada na segurança computacional proporcionada pelo fato de que “a fatoração de um número composto gigantesco é extremamente difícil”.

7.1 Como Funciona a Criptografia RSA (Geração de Chaves, Criptografia, Descriptografia)

Vamos ver o fluxo geral de comunicação da criptografia RSA com um diagrama de sequência Mermaid.

sequenceDiagram participant Alice["Alice (Destinatário)"] participant Bob["Bob (Remetente)"] Alice->>Alice: "Gera os primos gigantescos p e q" Alice->>Alice: "Calcula N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Calcula a chave pública e e a chave privada d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Envia a chave pública (N, e)" Note over Bob: "Prepara o texto simples M (M < N)" Bob->>Bob: "Calcula o texto cifrado C = M^e mod N" Bob->>Alice: "Envia o texto cifrado C" Alice->>Alice: "Calcula o texto simples M = C^d mod N para descriptografar"

Abaixo, explicaremos os passos matemáticos detalhados.

Passo 1: Geração de Chaves (Tarefa da destinatária Alice)

Gera dois números primos gigantescos aleatórios $p$ e $q$ (o método de teste de primalidade descrito acima é usado aqui).
Calcula o seu produto $N = p \times q$. Este $N$ torna-se público.
Usando a função totiente de Euler, calcula $\phi(N) = (p-1)(q-1)$.
Escolhe um número inteiro $e$ (expoente público) que seja coprimo com $\phi(N)$ (geralmente $e = 65537$ é usado).
Calcula o inverso modular $d$ (expoente privado) de $e$. Ou seja, encontra $d$ que satisfaça o seguinte: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Para esse cálculo, o Algoritmo de Euclides Estendido é usado.

Com isso, a chave pública é $(N, e)$ e a chave privada é $(N, d)$. (Eles descartam imediatamente ou ocultam estritamente $p, q, \phi(N)$).

Passo 2: Criptografia (Tarefa do remetente Bob)

Suponha que Bob queira enviar a mensagem $M$ para Alice ($M$ é uma representação numérica de caracteres, onde $0 \le M < N$). Bob usa a chave pública de Alice $(N, e)$ para realizar o seguinte cálculo e criar o texto cifrado $C$.

$$ C \equiv M^e \pmod N $$

Este $C$ é então enviado para Alice pela rede.

Passo 3: Descriptografia (Tarefa da destinatária Alice)

Ao receber o texto cifrado $C$, Alice realiza o seguinte cálculo usando a chave privada $d$ que apenas ela conhece.

$$ M' \equiv C^d \pmod N $$

Surpreendentemente, o resultado desse cálculo, $M'$, é exatamente igual à mensagem original $M$.

7.2 Por que pode ser Descriptografado? (Prova Matemática)

É aqui que o Pequeno Teorema de Fermat (Teorema de Euler) mostra seu verdadeiro valor. Por que $C^d \pmod N$ retorna a $M$?

Vamos expandir a equação de descriptografia. Como $C \equiv M^e \pmod N$,

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

No passo de geração da chave, $d$ foi escolhido para que $e \cdot d \equiv 1 \pmod{\phi(N)}$. Isso significa que existe um número inteiro $k$ tal que:

$$ e \cdot d = 1 + k \cdot \phi(N) $$

Substituindo isso na equação acima:

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

Aqui, entra o Teorema de Euler ($M^{\phi(N)} \equiv 1 \pmod N$). (Rigorosamente, $M$ e $N$ precisam ser coprimos, mas em RSA, a probabilidade de que $M$ e $N$ não sejam coprimos é astronomicamente baixa, e pelo Teorema Chinês do Resto, pode-se provar que é válido mesmo se não forem coprimos).

Aplicando o Teorema de Euler, como $M^{\phi(N)} \equiv 1$, temos:

$$ M \cdot (1)^k \equiv M \pmod N $$

$M$ foi perfeitamente restaurado! As propriedades dos números que Fermat e Euler descobriram há centenas de anos garantem perfeitamente a confidencialidade das comunicações digitais modernas.

8. Implementação da Criptografia RSA de Brinquedo (Python)

Uma vez que é difícil ter uma noção de como isso funciona baseando-se apenas na teoria, vamos usar o Python para implementar o processo de geração de chaves, criptografia e descriptografia da criptografia RSA na prática. Esta é uma “implementação de brinquedo” educacional, mas a matemática subjacente é exatamente a mesma.

O “Algoritmo de Euclides Estendido” para encontrar o inverso modular $d$ também será incluído na implementação.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# Encontrar o máximo divisor comum
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Algoritmo de Euclides Estendido (encontra x e y para ax + by = gcd(a,b))
# Usado para encontrar d para e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('O inverso não existe')
 else:
 return x % phi

# Função de geração de primos (Versão simples: gera números primos pequenos)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Substitui o teste de Fermat acima por um teste simplificado
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Geração de par de chaves RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Evita que p e q sejam iguais
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e costuma usar um número primo como 65537, mas vamos escolher aleatoriamente aqui
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Cálculo da chave privada d
 d = mod_inverse(e, phi)

 # Chave pública (e, n), chave privada (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Calcula plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Calcula cipher^d mod n e reverte para um caractere
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Exemplo de execução
if __name__ == '__main__':
 print("--- Implementação da Criptografia RSA de Brinquedo ---")
 public_key, private_key = generate_keypair(bits=12) # Usa um número primo de 12 bits

 print(f"Chave pública (e, n): {public_key}")
 print(f"Chave privada (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nMensagem original: {message}")

 # Criptografia
 encrypted_msg = encrypt(public_key, message)
 print(f"Texto cifrado: {encrypted_msg}")

 # Descriptografia
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Mensagem descriptografada: {decrypted_msg}")

Quando você executa este código, você pode confirmar como a matriz de caracteres é convertida em um array de números estranhos (texto cifrado), e como isso é restaurado perfeitamente para a string original através da chave privada.

9. Conclusão: A Intersecção entre a Beleza da Matemática e a Praticidade

Quando Pierre de Fermat descobriu este “pequeno teorema” no século 17, ninguém pensou que isso pudesse ser útil de alguma forma. O próprio Fermat conduziu suas pesquisas em teoria dos números com curiosidade puramente matemática.

No entanto, nos anos 1970, cerca de 300 anos depois, nos primórdios das redes de computadores, o teorema de Fermat fez um retorno dramático como uma tecnologia de criptografia essencial para estabelecer protocolos de comunicação seguros. A tecnologia do teste de primalidade baseada no Pequeno Teorema de Fermat e a Criptografia RSA, com base no Teorema de Euler, sustentam literalmente a infraestrutura moderna da internet.

Até mesmo a mensagem no LINE que enviamos casualmente todos os dias e nossas compras na Amazon, estão todas dançando no topo desta simples e bela fórmula: $a^{p-1} \equiv 1 \pmod p$. O Pequeno Teorema de Fermat nos ensina que, não importa o quão abstrata seja a matemática, o momento em que ela for útil para a humanidade sem dúvida chegará algum dia.

Ao aprender programação e teoria criptográfica, compreender a estrutura matemática em seus fundamentos será uma grande arma para o profundo entendimento do comportamento das bibliotecas fornecidas como caixas-pretas e para o design de sistemas mais seguros.

A intuição matemática da criptografia baseada em reticulados (Lattice-based cryptography)

Fri, 11 Sep 2026 21:00:00 +0900

1. Introdução: O alvorecer da Criptografia Pós-Quântica (PQC) e a ascensão da criptografia baseada em reticulados

A infraestrutura digital da sociedade moderna é sustentada por tecnologias de criptografia de chave pública, como a criptografia RSA e a Criptografia de Curva Elíptica (ECC). Esses métodos criptográficos baseiam sua segurança na dificuldade matemática de problemas como o “Problema de Fatoração de Inteiros” e o “Problema do Logaritmo Discreto”, que se acredita não poderem ser resolvidos eficientemente (exigindo tempo exponencial) pelos computadores clássicos convencionais.

No entanto, o “Algoritmo de Shor”, publicado por Peter Shor em 1994, enviou ondas de choque através do mundo da criptografia. Este algoritmo provou matematicamente que, uma vez realizados computadores quânticos de grande escala, problemas de fatoração de inteiros e logaritmos discretos serão resolvidos em tempo polinomial. Isso significa que a criptografia de chave pública amplamente utilizada hoje se tornará completamente decifrável no futuro.

Para combater essa “Ameaça Quântica (Quantum Threat)”, a pesquisa em novos métodos criptográficos que sejam difíceis de quebrar, mesmo usando computadores quânticos, tornou-se uma questão urgente. Este é o campo conhecido como “Criptografia Pós-Quântica (Post-Quantum Cryptography: PQC)” ou “Criptografia resistente a quantum”.

Existem vários candidatos fortes para PQC. Estes incluem criptografia baseada em hash, criptografia baseada em código, criptografia polinomial multivariada e criptografia baseada em isogenia. Entre eles, o que atualmente atrai mais atenção e é fundamental para o processo de padronização PQC do NIST (Instituto Nacional de Padrões e Tecnologia dos EUA) é a “Criptografia baseada em reticulados (Lattice-based cryptography)”. Em comparação com outros métodos, a criptografia baseada em reticulados possui velocidades de criptografia e descriptografia extremamente rápidas e exibe uma característica notável em sua prova de segurança: uma redução da “complexidade do pior caso (Worst-case complexity)” para a “complexidade do caso médio (Average-case complexity)”, que é extremamente poderosa na teoria criptográfica.

Neste artigo, começaremos pela definição matemática fundamental de um “Reticulado (Lattice)”, que é a base da criptografia baseada em reticulados, e explicaremos profundamente problemas difíceis em reticulados como SVP (Problema do Vetor Mais Curto) e CVP (Problema do Vetor Mais Próximo), e o núcleo da criptografia de reticulados moderna, o “Problema LWE (Learning With Errors)”, usando fórmulas, intuição geométrica e exemplos numéricos concretos.

2. Definição Matemática e Intuição Geométrica do Reticulado (Lattice)

2.1 Espaço Vetorial e Reticulados

Em matemática, um “Reticulado (Lattice)” é um conjunto de pontos discretos dispostos regularmente em um espaço vetorial real de dimensão $n$, $\mathbb{R}^n$. É semelhante a um espaço vetorial (Vector Space) aprendido em álgebra linear, mas há uma diferença crucial. Enquanto um espaço vetorial é um espaço contínuo representado por combinações lineares com “coeficientes reais” dos vetores de base, um reticulado é um espaço discreto representado por combinações lineares com “coeficientes inteiros” dos vetores de base.

Vamos dar uma definição matemática rigorosa. Considere $n$ vetores linearmente independentes ($n \le m$) $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ em um espaço vetorial real de dimensão $m$, $\mathbb{R}^m$. Considere uma matriz cujos vetores coluna são esses vetores: $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. Esta $B$ é chamada de “Base (Basis)” do reticulado.

O reticulado $\mathcal{L}(B)$ gerado por esta base $B$ é definido da seguinte forma:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

O ponto importante aqui é que os coeficientes $x_i$ são restritos a inteiros $\mathbb{Z}$, e não a números reais $\mathbb{R}$. Isso forma um “conjunto de pontos discretos” semelhante a cruzamentos espaçados uniformemente, em vez dos infinitos pontos contínuos no espaço.

2.2 Imagem Geométrica

Vamos considerar um exemplo em um plano bidimensional $\mathbb{R}^2$. Se escolhermos $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ e $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ como vetores de base, o reticulado gerado por eles será o conjunto de todas as coordenadas inteiras $(x, y) \in \mathbb{Z}^2$ no plano cartesiano. Este é o “reticulado quadrado” mais simples.

No entanto, reticulados nem sempre são ortogonais. Por exemplo, considerando a base $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ e $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, os pontos gerados serão como as interseções de uma malha distorcida diagonalmente.

2.3 Não Unicidade da Base e Transformação Unimodular

Há uma propriedade importante relacionada ao núcleo da segurança da criptografia baseada em reticulados. É que “existem infinitas bases que geram o mesmo reticulado”.

Por exemplo, a base anterior $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ que gera o reticulado $\mathbb{Z}^2$ também gerará exatamente o mesmo reticulado $\mathbb{Z}^2$ se usarmos a base $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$.

A condição necessária e suficiente para uma certa base $B$ e outra base $B'$ gerarem o mesmo reticulado é que exista uma matriz com componentes inteiros $U \in \mathbb{Z}^{n \times n}$ tal que seu determinante seja $\det(U) = \pm 1$, e possa ser expressa como:

$$ B' = B U $$

Tal matriz $U$ é chamada de “matriz unimodular (Unimodular matrix)”.

A ideia básica em aplicações criptográficas é usar uma “boa base (uma base próxima de ser ortogonal, consistindo de vetores curtos)” como chave privada, e uma “base ruim (uma base consistindo de vetores extremamente oblíquos entre si e muito longos)” como chave pública. Calcular uma boa base a partir de uma base ruim torna-se extremamente difícil à medida que a dimensão aumenta. Esta é a intuição básica da criptografia baseada em reticulados.

3. Problemas Computacionalmente Difíceis em Reticulados

A segurança da criptografia baseada em reticulados depende da dificuldade de resolver certos problemas matemáticos sobre reticulados. Aqui, introduziremos os dois problemas mais fundamentais e famosos.

3.1 Problema do Vetor Mais Curto (Shortest Vector Problem: SVP)

SVP é o problema mais clássico e famoso na teoria dos reticulados.

Definição (SVP): Dada qualquer base de reticulado $B$, encontre o vetor não nulo $\mathbf{v}$ pertencente ao reticulado $\mathcal{L}(B)$ cuja norma euclidiana (comprimento) seja mínima.

Expressando em fórmula, é o problema de encontrar $\mathbf{v}$ tal que $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Este comprimento mínimo é denotado como $\lambda_1(\mathcal{L})$ e é chamado de “Primeiro mínimo sucessivo (First successive minimum)” do reticulado.

Em dimensões baixas, como 2D ou 3D, você pode desenhar uma figura e encontrar visualmente o vetor mais curto. Alternativamente, algoritmos de redução de base de Gauss podem resolvê-lo eficientemente. No entanto, sabe-se que em altas dimensões (por exemplo, dimensão $n$ na casa das centenas a milhares), resolver o SVP de forma exata é NP-difícil.

Em criptografia do mundo real, em vez do vetor mais curto exato, é usado o SVP aproximado ($\gamma$-SVP) para encontrar um “vetor aproximadamente curto”. Se o fator de aproximação $\gamma$ for de tamanho polinomial, este problema ainda é considerado extremamente difícil.

3.2 Problema do Vetor Mais Próximo (Closest Vector Problem: CVP)

CVP também é um problema extremamente importante na criptografia baseada em reticulados.

Definição (CVP): Dada qualquer base de reticulado $B$ e qualquer vetor alvo no espaço $\mathbf{t} \in \mathbb{R}^m$ (não necessariamente um ponto do reticulado), encontre o ponto do reticulado $\mathbf{v} \in \mathcal{L}(B)$ que seja o mais próximo de $\mathbf{t}$.

Expressando em fórmula, é o problema de procurar o ponto do reticulado $\mathbf{v}$ que resulta em $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

O CVP também é NP-difícil em altas dimensões, semelhante ao SVP. Do ponto de vista das aplicações criptográficas, o problema LWE, descrito posteriormente, está intimamente relacionado a uma variante especial do CVP (Bounded Distance Decoding: BDD).

3.3 Por que não pode ser resolvido em altas dimensões? (Os Limites do LLL e BKZ)

Um algoritmo famoso para resolver problemas de reticulados em altas dimensões é o algoritmo LLL (algoritmo de Lenstra-Lenstra-Lovász). O algoritmo LLL opera em tempo polinomial e pode reduzir a base do reticulado a uma “boa base” em certa medida. No entanto, o vetor mais curto encontrado pelo algoritmo LLL tem um fator de aproximação exponencial ($2^{\mathcal{O}(n)}$) em relação ao comprimento do vetor mais curto verdadeiro, portanto, não chega ao ponto de quebrar a segurança criptográfica.

Usar algoritmos de redução de base mais poderosos como o algoritmo BKZ (Block Korkine-Zolotarev), que é uma melhoria do LLL, permite encontrar vetores mais curtos, mas seu tempo de computação aumenta exponencialmente em relação ao tamanho do bloco. Na criptografia baseada em reticulados, parâmetros seguros (como o tamanho da dimensão $n$) são determinados estimando o tempo de execução deste algoritmo BKZ. Nos parâmetros padrão atuais da PQC, são escolhidos valores entre 500 e 1000 ou mais para a dimensão $n$, e estima-se que levaria mais tempo do que a idade do universo para decifrá-los, mesmo com supercomputadores ou computadores quânticos futuros.

4. Formulação Matemática do Problema LWE (Learning With Errors)

A maior parte da criptografia moderna baseada em reticulados é baseada no “Problema LWE (Learning With Errors)”, proposto por Oded Regev em 2005. A beleza do problema LWE reside na simplicidade de sua formulação e em ter uma prova matemática poderosa: a “redução da complexidade do pior caso para a complexidade do caso médio”.

4.1 Equações lineares simultâneas sem ruído

Para entender o problema LWE, vamos primeiro considerar equações lineares simultâneas simples sem ruído. Suponha que haja um vetor secreto desconhecido $\mathbf{s} \in \mathbb{Z}_q^n$ (cada componente é um número inteiro de $0$ a $q-1$). Aqui, $q$ é considerado um número primo.

Escolhemos vetores de coeficientes aleatórios $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$, e calculamos seu produto escalar com o vetor secreto $\mathbf{s}$ módulo $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Se nos derem um número suficiente (pelo menos $n$) de pares $(\mathbf{a}_i, b_i)$, podemos restaurar facilmente o vetor secreto $\mathbf{s}$ usando a “Eliminação Gaussiana (Gaussian elimination)” em álgebra linear. Este é um problema que pode ser resolvido facilmente em tempo polinomial.

4.2 Definição do problema LWE: Adicionando Ruído

Então, o que acontece se adicionarmos um pouco de “ruído (erro)” a este problema? Esta é a essência do problema LWE.

Para o vetor secreto desconhecido $\mathbf{s} \in \mathbb{Z}_q^n$, adicionamos um pequeno erro $e_i \in \mathbb{Z}_q$ ao resultado de cada equação. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Aqui, $e_i$ é um número inteiro pequeno com média 0 e desvio padrão relativamente pequeno (por exemplo, retirado de uma distribuição Gaussiana discreta, como uma distribuição normal). A informação fornecida é uma lista de pares do vetor aleatório $\mathbf{a}_i$ e $b_i$ calculado adicionando o erro. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Expressar isso em forma de matriz o torna muito claro. Usando uma matriz aleatória $A \in \mathbb{Z}_q^{m \times n}$, um vetor secreto $\mathbf{s} \in \mathbb{Z}_q^n$, e um vetor de erro $\mathbf{e} \in \mathbb{Z}_q^m$,

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

pode ser escrito. Apenas $A$ e $\mathbf{b}$ são fornecidos. Encontrar $\mathbf{s}$ a partir disso é o “Problema de busca LWE (Search LWE problem)”.

Como o erro $e_i$ está incluído, ao tentar usar a eliminação gaussiana, o erro será amplificado exponencialmente durante o processo de adição e subtração de equações, tornando impossível chegar à resposta correta. À primeira vista, parecem equações lineares simultâneas simples, mas apenas adicionando esse pequeno ruído, o nível de dificuldade do problema salta para um nível NP-difícil.

4.3 Problema LWE de decisão (Decision LWE)

O que é frequentemente usado em provas na teoria criptográfica é uma variação do problema de busca LWE chamado de “Problema LWE de decisão (Decision LWE problem)”.

O problema de decisão LWE é o problema de determinar de qual de duas distribuições uma lista de amostras fornecida se origina.

Distribuição LWE: Intencionalmente calculada $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
Distribuição aleatória uniforme: $(A, \mathbf{u})$ que consiste em uma matriz completamente escolhida aleatoriamente $A$ e vetor $\mathbf{u}$

Surpreendentemente, se os parâmetros do problema LWE forem escolhidos de forma apropriada, pares de dados da distribuição LWE tornam-se “computacionalmente indistinguíveis (Computationally Indistinguishable)” de pares de dados completamente aleatórios. Esta propriedade é a base pela qual os cifradores baseados em LWE podem gerar “textos cifrados indistinguíveis de números aleatórios”.

4.4 Redução da complexidade do pior caso para a complexidade do caso médio (Teorema de Regev)

A maior conquista de Oded Regev foi ter vinculado matematicamente a dificuldade deste problema LWE à dificuldade dos problemas de reticulados (SVP e CVP) mencionados acima.

Ele usou a redução quântica (Quantum reduction) para provar que “Se existe um algoritmo de tempo polinomial que pode resolver o problema LWE na média (para $A$ e $\mathbf{e}$ escolhidos aleatoriamente), então existe um algoritmo quântico de tempo polinomial que pode resolver o Gap-SVP no pior caso (o caso mais difícil) para qualquer reticulado”. (Mais tarde, Peikert e outros também mostraram a redução clássica).

Esta é uma propriedade dos sonhos na teoria criptográfica. Porque dissipa a preocupação de que “a criptografia possa ser quebrada porque por acaso escolhemos uma chave fraca (uma parte do caso médio)” e nos dá a poderosa garantia de que “Se o LWE médio puder ser resolvido, todos os problemas difíceis do reticulado poderão ser resolvidos (portanto, o LWE é absolutamente difícil)”.

graph TD A["Problemas de Reticulado de Pior Caso (Gap-SVP, SIVP)"] -->|Redução Quântica/Clássica| B["Problema LWE de Caso Médio"] B -->|Construção Criptográfica| C["Sistemas Criptográficos baseados em LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Construção do Cifrador de Chave Pública usando LWE (Cifrador Regev)

Agora que entendemos a dificuldade do problema LWE, vamos ver a criptografia de chave pública básica proposta por Oded Regev para ver como ela é usada para criptografia e descriptografia. Aqui, explicaremos o mecanismo mais básico para criptografar uma mensagem de 1 bit $M \in \{0, 1\}$.

5.1 Geração de chaves (Key Generation)

Determine o módulo primo $q$, a dimensão $n$, e o número de equações $m$ ($m > n \log q$) como parâmetros do sistema.
Como uma chave privada, escolha um vetor $\mathbf{s} \in \mathbb{Z}_q^n$ aleatoriamente.
Gere uma matriz aleatória $A \in \mathbb{Z}_q^{m \times n}$.
Escolha um vetor de erro pequeno $\mathbf{e} \in \mathbb{Z}_q^m$ a partir de uma distribuição de erro como a distribuição gaussiana discreta.
Calcule o vetor $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
A chave pública (Public Key) será $(A, \mathbf{b})$.
A chave privada (Secret Key) será $\mathbf{s}$.

A chave pública é exatamente a “instância do problema LWE” em si. Uma vez que encontrar a chave privada $\mathbf{s}$ a partir da chave pública $(A, \mathbf{b})$ é equivalente a resolver o problema de busca LWE, a segurança é garantida.

5.2 Criptografia (Encryption)

Alice usa a chave pública de Bob $(A, \mathbf{b})$ para criptografar a mensagem de 1 bit $M \in \{0, 1\}$.

Escolha um vetor binário aleatório (composto de zeros ou uns) $\mathbf{r} \in \{0, 1\}^m$.
Como a primeira metade do texto cifrado, calcule o vetor $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ é a matriz transposta de $A$. Em outras palavras, está somando as linhas de $A$ onde os componentes de $\mathbf{r}$ são 1).
Como a segunda metade do texto cifrado, calcule o escalar $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Se a mensagem $M$ for 0, nada é adicionado; se for $1$, é adicionado o valor exatamente da metade de $q$, $\lfloor \frac{q}{2} \rfloor$).
O texto cifrado (Ciphertext) será $(\mathbf{u}, v)$.

O significado intuitivo da criptografia é pegar a “soma de um subconjunto aleatório” para a matriz de chave pública $A$ e o vetor $\mathbf{b}$. Devido à dificuldade do problema LWE de decisão, esse texto cifrado $(\mathbf{u}, v)$ parece indistinguível de um vetor completamente aleatório e um número aleatório uniforme (Segurança semântica: Semantic Security).

flowchart LR M["Mensagem M em {0,1}"] --> Enc PK["Chave Pública (A, b)"] --> Enc r["Vetor binário aleatório r"] --> Enc subgraph Enc ["Processo de Criptografia"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Texto Cifrado (u, v)"]

5.3 Descriptografia (Decryption)

Bob descriptografa o texto cifrado $(\mathbf{u}, v)$ usando a chave secreta $\mathbf{s}$.

Calcule o seguinte valor: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Se o resultado calculado estiver mais próximo de $0$, a saída é $M=0$; se estiver mais próximo de $\lfloor \frac{q}{2} \rfloor$, a saída é $M=1$.

Vamos expandir matematicamente para ver por que isso permite a descriptografia. Lembre-se de que $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Aqui, $\mathbf{s}^T A^T \mathbf{r}$ foi perfeitamente cancelado e desapareceu da fórmula! O que restou foi $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ é um vetor de ruído cujos componentes são extremamente pequenos, e $\mathbf{r}$ é um vetor binário cujos componentes são 0 ou 1. Portanto, o produto escalar deles, $\mathbf{e}^T \mathbf{r}$, também permanece em um valor relativamente pequeno (se os parâmetros forem escolhidos apropriadamente).

Se $M=0$, o resultado é $\mathbf{e}^T \mathbf{r}$, o que será um valor pequeno próximo de $0$.
Se $M=1$, o resultado é $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, o qual ficará próximo da metade do valor de $q$, $\lfloor \frac{q}{2} \rfloor$.

Se os parâmetros forem desenhados para que o valor absoluto do erro $\mathbf{e}^T \mathbf{r}$ fique abaixo de $\frac{q}{4}$, Bob pode determinar (descriptografar) com precisão a mensagem $M$ apenas olhando se o resultado do cálculo está mais próximo de $0$ ou $\lfloor \frac{q}{2} \rfloor$. Este é o belo mecanismo pelo qual os cifradores baseados em LWE funcionam.

flowchart LR CT["Texto Cifrado (u, v)"] --> Dec SK["Chave Secreta s"] --> Dec subgraph Dec ["Processo de Descriptografia"] direction TB calc["Calcular D = v - s^T * u mod q"] check["Verificar se D está mais próximo de 0 ou q/2"] end calc --> check Dec --> M_out["Mensagem Recuperada M"]

6. Exemplo Prático (Toy Example) de Criptografia LWE com Valores Numéricos Específicos

Pode ser difícil ter uma noção apenas listando equações, então vamos tentar definir parâmetros numéricos muito pequenos e seguir o cálculo desde a criptografia até a descriptografia. (*Em sistemas criptográficos do mundo real, são utilizados valores para $n$ superiores a 500 e $q$ superiores a milhares para garantir a segurança.)

[Configuração de Parâmetros]

Módulo $q = 17$ (Número primo. Assim, os valores variam de $0$ a $16$)
Dimensão $n = 2$
Número de equações $m = 4$
Suponha que vamos criptografar a mensagem $M = 1$.
Quantidade de deslocamento da mensagem: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Fase de Geração de Chaves] Bob seleciona a chave privada $\mathbf{s}$, a matriz $A$ e o vetor de erro $\mathbf{e}$ aleatoriamente.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Em seguida, ele calcula a chave pública $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Calculando isto no módulo 17 (por exemplo, $66 = 17 \times 3 + 15$):

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Adicionando o vetor de erro $\mathbf{e}$:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

A chave pública será $A$ e $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Fase de Criptografia] Alice criptografa a mensagem $M = 1$. Ela escolhe um vetor aleatório $\mathbf{r}$. Aqui, assumiremos $\mathbf{r} = (1, 0, 1, 0)^T$.

Calculando $\mathbf{u}$:

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Calculando $v$:

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Ela adiciona o valor $\lfloor 17/2 \rfloor = 8$ correspondente à mensagem $M=1$.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Alice envia o texto cifrado $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ para Bob.

[3. Fase de Descriptografia] Ao receber o texto cifrado, Bob descriptografa usando a chave secreta $\mathbf{s} = (3, 4)^T$. Fórmula do processo de descriptografia: Ele calcula $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Aqui, no mundo de módulo 17, $-8$ é equivalente a $9$ ($-8 + 17 = 9$). Ele verifica se o valor obtido $D = 9$ está mais próximo de $0$ ou $8$ ($\lfloor 17/2 \rfloor$). Uma vez que $9$ é claramente mais próximo de $8$ do que de $0$, Bob conseguiu recuperar corretamente $M = 1$!

Por que se tornou $9$? Lembre-se da prova anterior. A parte do erro é $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Portanto, o resultado do cálculo é $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, confirmando que o valor teórico foi calculado.

7. Evolução para a Prática: Ring-LWE e Module-LWE

O problema LWE Padrão (Standard LWE) explicado até agora possui provas de segurança muito fortes, mas tem uma fraqueza fatal na prática. Esta é o “tamanho da chave torna-se enorme” e “os custos de computação são elevados”.

No Standard LWE, a chave pública contém uma matriz enorme $A \in \mathbb{Z}_q^{m \times n}$. Quando o parâmetro $n$ atinge centenas ou milhares, o tamanho dessa matriz chega a vários megabytes, o que a torna muito pesada para transmissão através de protocolos de comunicação na internet (como TLS) todas as vezes. Além disso, a multiplicação entre matrizes e vetores requer complexidade computacional de $\mathcal{O}(n^2)$.

Para resolver esse problema, “Ring-LWE (RLWE)” e “Module-LWE (MLWE)” foram introduzidos, incorporando a estrutura algébrica dos anéis de polinômios (Polynomial rings) aos reticulados.

7.1 A Intuição do Ring-LWE

No Ring-LWE, vetores e matrizes são substituídos por elementos (polinômios) em um anel de polinômios $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Aqui, $n$ é escolhido como uma potência de 2).

Enquanto a chave pública no LWE Padrão era uma matriz $A$, o Ring-LWE usa um único polinômio $a(x)$. A chave privada $s(x)$ e o erro $e(x)$ também se tornam polinômios. A equação fica assim:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Por ser uma multiplicação polinomial, ao usar a “Transformada Numérica de Teoria (Number Theoretic Transform: NTT)”, que é análoga à Transformada Rápida de Fourier (FFT), o custo computacional pode ser drasticamente reduzido para $\mathcal{O}(n \log n)$. Além disso, dado que o tamanho da chave pública é reduzido de uma matriz para um único polinômio, o tamanho dos dados é reduzido para $\mathcal{O}(n)$. Isso traz uma vantagem esmagadora na largura de banda de comunicação.

Matematicamente falando, o Ring-LWE não é sobre reticulados gerais, mas reduz-se a problemas em um reticulado especial simétrico chamado “Reticulado Ideal (Ideal Lattice)”.

7.2 Module-LWE e a Padronização do NIST (Kyber / ML-KEM)

Embora o Ring-LWE seja eficiente, houve alguma preocupação de que a estrutura algébrica especial dos reticulados ideais pudesse se tornar a base para ataques futuros. Portanto, foi criado o “Module-LWE (MLWE)” para obter “o melhor dos dois mundos”, combinando a segurança conservadora do LWE Padrão com a eficiência do Ring-LWE.

No Module-LWE, consideramos pequenos vetores e matrizes cujos elementos são polinômios. Ou seja, lidamos com módulos (modules) sobre um anel. Atualmente, o “CRYSTALS-Kyber” (nome padronizado: ML-KEM), selecionado pelo NIST como o padrão para algoritmos de compartilhamento de chaves (KEM) da PQC, é construído exatamente sobre a dificuldade desse problema Module-LWE.

8. Por que é seguro contra computadores quânticos?

Por fim, tocaremos na questão central: “Por que se acredita que a criptografia baseada em reticulados não pode ser decifrada nem mesmo por computadores quânticos?”.

O algoritmo de Shor, que permite aos computadores quânticos quebrar a criptografia RSA ou a criptografia de curvas elípticas, é essencialmente um algoritmo para resolver o “Problema do Subgrupo Oculto (Hidden Subgroup Problem: HSP)”. As estruturas matemáticas subjacentes à RSA e à ECC (grupos abelianos finitos) possuem periodicidade, e usando a operação específica de algoritmos quânticos chamada Transformada de Fourier Quântica (QFT), esse período (subgrupo oculto) pode ser extraído de uma vez.

Contudo, os problemas de reticulados são fundamentalmente diferentes. Embora os reticulados também tenham periodicidade, o que é requerido em problemas como SVP e CVP são propriedades geométricas não-lineares, como “a distância mais curta” e “a remoção de ruído”. Mesmo que se aplique a “transformada de Fourier quântica sobre grupos abelianos” como no algoritmo de Shor diretamente, informações úteis que poderiam ser a resposta a problemas de reticulados não podem ser extraídas eficientemente. Até o momento, não foram descobertos algoritmos quânticos que resolvam SVP ou LWE em tempo polinomial e acredita-se amplamente que, mesmo com a capacidade de computação paralela dos computadores quânticos, não exista meio eficaz além de uma busca por força bruta (com uma aceleração na raiz quadrada pelo algoritmo de Grover).

9. Conclusão

Neste artigo, explicamos em detalhes a intuição matemática da criptografia baseada em reticulados, começando pela definição geométrica de um reticulado, a formulação do problema LWE e culminando na construção da criptografia de chave pública.

Reticulado (Lattice) é um espaço discreto expresso por uma combinação linear com coeficientes inteiros de vetores de base, e em dimensões altas, torna-se difícil encontrar uma “boa base” quase ortogonal (SVP).
O Problema LWE (Learning With Errors) é o problema de resolver um sistema de equações lineares com ruído, e por estar vinculado à dificuldade do caso mais difícil dos problemas de reticulados, oferece uma poderosa garantia de segurança.
Ao usar o problema LWE, a criptografia e descriptografia (Cifrador Regev) são alcançadas através de um mecanismo inteligente de adição e cancelamento intencional de ruídos.
Em protocolos do mundo real, o Ring-LWE e o Module-LWE usando anéis de polinômios são adotados para aumentar a eficiência de comunicação e velocidade computacional, formando a base do padrão NIST ML-KEM.

À medida que nos aproximamos de uma mudança de paradigma computacional sem precedentes chamada computador quântico, é uma história muito romântica que a “Criptografia baseada em reticulados”, nascida das profundezas da álgebra linear clássica e da teoria dos números, apoiará a fundação da segurança da internet no futuro. A matemática que fundamenta a criptografia de reticulados não é excessivamente complexa, e com conhecimentos básicos de álgebra linear e probabilidade, pode-se entender completamente sua bela estrutura. Esperamos que este artigo ajude na compreensão da criptografia baseada em reticulados, que é o cerne da PQC.

O Funcionamento das Provas de Conhecimento Zero (ZKP) e as Últimas Aplicações em Web3 e Segurança

Fri, 11 Sep 2026 19:00:00 +0900

Introdução

Na sociedade digital moderna, a privacidade de dados e a escalabilidade tornaram-se dois dos desafios mais importantes. Com o aumento do risco de vazamento de informações pessoais e uso não autorizado, há uma forte demanda por tecnologias que permitam “provar que você possui determinada informação sem revelá-la à outra parte”. Isso é alcançado pela Prova de Conhecimento Zero (Zero-Knowledge Proof: ZKP).

A Prova de Conhecimento Zero é um conceito de teoria criptográfica proposto pela primeira vez na década de 1980 por Shafi Goldwasser, Silvio Micali e Charles Rackoff, mas que permaneceu restrito à pesquisa teórica por um longo tempo. No entanto, com a ascensão da tecnologia blockchain e da Web3, a situação mudou drasticamente. A ZKP ganhou destaque repentino como a “varinha mágica” para resolver simultaneamente o problema de escalabilidade (limites de capacidade de processamento) e o problema de privacidade (todas as transações sendo públicas) enfrentados por blockchains públicas como o Ethereum.

Neste artigo, exploraremos detalhadamente e tecnicamente desde os conceitos fundamentais das Provas de Conhecimento Zero, os profundos mecanismos matemáticos e criptográficos dos atualmente populares zk-SNARKs e zk-STARKs, até os exemplos mais recentes de aplicações em Web3 e segurança, como ZK-Rollups e Identidade Descentralizada (DID).

O que é uma Prova de Conhecimento Zero (ZKP)?

Uma Prova de Conhecimento Zero (ZKP) refere-se a um protocolo onde, ao provar que uma certa proposição é verdadeira, um provador (Prover) não transmite nenhuma informação a um verificador (Verifier) “além do fato de que a proposição é verdadeira”.

3 Requisitos que a ZKP Deve Satisfazer

Para ser estabelecida como uma ZKP, os três seguintes atributos devem ser estritamente atendidos:

Completude (Completeness) Se a proposição for verdadeira e tanto o provador quanto o verificador seguirem o protocolo corretamente, o verificador deve aceitar (Accept) a prova com uma probabilidade esmagadora.
Solidez (Soundness) Se a proposição for falsa, mesmo o provador mais malicioso e com grande poder computacional não poderá enganar o verificador para aceitar a prova (exceto por uma probabilidade insignificantemente pequena).
Conhecimento Zero (Zero-Knowledge) Se a proposição for verdadeira, o verificador não pode obter do processo de prova nenhuma informação além do fato de que “a proposição é verdadeira”. Do ponto de vista do verificador, prova-se por definição matemática que é possível simular o processo de prova (existe um simulador).

Provas Interativas e Não Interativas

Existem dois tipos de ZKP: provas interativas (Interactive ZKP), onde o provador e o verificador se comunicam múltiplas vezes, e provas não interativas (Non-Interactive ZKP), onde o provador envia os dados da prova apenas uma vez e finaliza.

Provas Interativas (Interactive ZKP)

As primeiras ZKPs foram projetadas como protocolos interativos. A famosa alegoria da “Caverna de Ali Babá” enquadra-se nisso. O fluxo geral do protocolo é o seguinte:

sequenceDiagram participant Prover as "Prover (Provador)" participant Verifier as "Verifier (Verificador)" Note over Prover, Verifier: "Fluxo básico do protocolo de prova interativa" Prover->>Verifier: "1. Enviar compromisso (Commitment)" Verifier->>Prover: "2. Enviar desafio aleatório (Challenge)" Prover->>Verifier: "3. Calcular e enviar resposta (Response)" Note over Verifier: "Verificar a resposta (Verification)" Verifier-->>Prover: "4. Aceitar ou rejeitar (Accept / Reject)" Note over Prover, Verifier: "※Para aumentar a certeza, isso é repetido dezenas de vezes"

Este método é poderoso, mas o verificador deve estar online, o que o torna inconveniente para aplicação em sistemas distribuídos assíncronos como blockchain. Em uma blockchain, qualquer pessoa deve ser capaz de verificar provas passadas a qualquer momento.

Transformação de Fiat-Shamir (Fiat-Shamir Heuristic) e Não Interatividade

A Transformação de Fiat-Shamir é um método inovador para converter uma prova interativa em uma prova não interativa (Non-Interactive Zero-Knowledge Proof: NIZK).

Em vez do “desafio aleatório” enviado pelo verificador, o provador autogera um “desafio pseudoaleatório” usando seu próprio compromisso e o valor de hash das informações públicas. Assumindo que uma função de hash criptográfica (como SHA-256 ou Keccak) funcione como um oráculo aleatório, o provador não pode prever ou manipular o desafio antecipadamente e pode completar a prova com um único envio de mensagem, mantendo a mesma segurança de uma prova interativa.

Detalhes Técnicos de zk-SNARKs

Atualmente, a ZKP mais amplamente utilizada é o zk-SNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge). Como o nome sugere, é um argumento de conhecimento (Argument of Knowledge) que possui conhecimento zero (zk), tamanho de prova muito pequeno e verificação rápida (Succinct) e é não interativo (Non-Interactive).

A base do zk-SNARKs é a geometria algébrica avançada e a teoria criptográfica. Ele converte a execução ou cálculo de um programa na verificação de uma equação polinomial específica.

1. Conversão para Circuitos Aritméticos e R1CS (Rank-1 Constraint System)

Primeiro, qualquer cálculo a ser provado (um algoritmo ou lógica de contrato inteligente) é convertido em um circuito aritmético (Arithmetic Circuit) que consiste em portas de adição e portas de multiplicação.

Em seguida, este circuito aritmético é convertido em um conjunto de equações de matriz chamado R1CS (Rank-1 Constraint System). O R1CS é o problema de encontrar matrizes $A, B, C$ que satisfaçam a seguinte restrição para um vetor de variáveis $x$:

$$ (A \cdot x) \circ (B \cdot x) = C \cdot x $$

Aqui, $\circ$ representa o produto de Hadamard (produto elemento a elemento). Essa restrição garante que todas as portas lógicas do circuito (especialmente as portas de multiplicação) sejam calculadas corretamente.

2. Conversão para QAP (Quadratic Arithmetic Program)

Como existem inúmeras restrições de matriz do R1CS, verificá-las individualmente é muito ineficiente. Portanto, usando a interpolação de Lagrange, essas restrições são comprimidas em uma única equação polinomial. Isso é o QAP (Quadratic Arithmetic Program).

Ao converter para QAP, o problema a ser provado se reduz ao problema de “Pode um polinômio específico $P(x)$ ser divisível por outro polinômio conhecido $Z(x)$?”.

$$ P(x) = L(x) \cdot R(x) - O(x) $$

Aqui, $L(x), R(x), O(x)$ são combinações dos polinômios correspondentes a cada linha das matrizes $A, B, C$, respectivamente. Se o provador souber a solução correta (Witness), o valor em cada raiz (ponto de avaliação) de $P(x)$ será 0, portanto, $P(x)$ terá o polinômio alvo $Z(x)$ como um fator. Ou seja, existe um polinômio $H(x)$ e a seguinte equação se mantém:

$$ P(x) = H(x) \cdot Z(x) $$

O verificador pode verificar instantaneamente se todo o cálculo foi realizado corretamente apenas verificando se esta equação $P(s) = H(s) \cdot Z(s)$ se mantém em um ponto secreto aleatório $s$. Esse é o segredo da “Sucintez (Succinctness)”.

3. Criptografia de Curva Elíptica e Emparelhamentos (Bilinear Pairings)

No entanto, se o verificador souber o ponto secreto $s$, o provador poderá forjar um polinômio falso para satisfazer a equação (quebra da solidez). Portanto, é necessário realizar o cálculo mantendo $s$ criptografado (usando criptografia homomórfica) para que ninguém o conheça.

Isto é alcançado pelos emparelhamentos de curva elíptica (Bilinear Pairings). Um emparelhamento $e$ é uma função especial que pode calcular um valor equivalente à criptografia de seu produto a partir de dois valores criptografados.

$$ e(g_1^a, g_2^b) = e(g_1, g_2)^{ab} $$

O provador pode calcular os valores criptografados dos polinômios $P(s)$ e $H(s)$ usando o valor criptografado da potência de $s$ (chamado de CRS: Common Reference String), mesmo sem conhecer o próprio $s$. O verificador utiliza a função de emparelhamento para verificar se a relação $P(s) = H(s) \cdot Z(s)$ é mantida enquanto os valores permanecem criptografados.

4. Configuração Confiável (Trusted Setup)

A maior fraqueza dos zk-SNARKs (especialmente os iniciais como o Groth16) é que eles requerem um processo para gerar o ponto secreto $s$, chamado de Configuração Confiável (Trusted Setup). Se o criador do $s$ mantiver o valor em vez de destruí-lo, ele poderá gerar qualquer prova falsa (problema do Lixo Tóxico / Toxic Waste).

Para prevenir isso, é realizada uma cerimônia chamada “Ceremony”, que utiliza Computação Multipartidária (MPC). Vários participantes colaboram para fornecer aleatoriedade, e se pelo menos um participante destruir honestamente seu próprio valor aleatório, a segurança de todo o sistema é mantida. No entanto, pesquisas para eliminar essa dependência vêm sendo conduzidas há muitos anos.

Detalhes Técnicos de zk-STARKs

Como resposta à dependência da Configuração Confiável e ao risco de decodificação da criptografia de curva elíptica por computadores quânticos, surgiram os zk-STARKs (Zero-Knowledge Scalable Transparent Argument of Knowledge).

Desenvolvido por Eli Ben-Sasson e outros, o STARKs não requer nenhuma Configuração Confiável (Trusted Setup), como o nome “Transparente (Transparent)” sugere, e tem a característica de que o tamanho da prova e o tempo de verificação são mantidos eficientes mesmo se o volume de cálculo aumentar, como sugere o nome “Escalável (Scalable)”.

1. Compromisso Polinomial e Protocolo FRI

Os zk-STARKs não dependem de criptografia de curva elíptica, mas ancoram a sua segurança apenas em funções hash. Portanto, eles possuem propriedades de criptografia pós-quântica (Post-Quantum Cryptography).

A verificação do cálculo é realizada convertendo-o num formato chamado AIR (Algebraic Intermediate Representation) e, em seguida, utilizando as propriedades dos polinómios unidimensionais ou multidimensionais. O núcleo do STARKs está no protocolo FRI (Fast Reed-Solomon Interactive Oracle Proof of Proximity).

O protocolo FRI é uma tecnologia para verificar “se uma determinada função está suficientemente próxima de um polinômio de um grau específico (Proximity)”. O provador compromete os valores do polinômio como folhas de uma árvore de Merkle (Merkle Tree) (compromisso polinomial).

graph TD Root["Merkle Root (Compromisso)"] --> Node0["Nó 0"] Root --> Node1["Nó 1"] Node0 --> Leaf0["P(x_0)"] Node0 --> Leaf1["P(x_1)"] Node1 --> Leaf2["P(x_2)"] Node1 --> Leaf3["P(x_3)"]

O verificador exige a revelação de alguns pontos aleatórios e utiliza provas de Merkle (Merkle Proofs) para confirmar que estão incluídos no compromisso. Ao repetir isso recursivamente, garante-se com probabilidade esmagadora que o grau do polinômio original é realmente baixo.

Comparação entre zk-SNARKs e zk-STARKs

Característica	zk-SNARKs	zk-STARKs
Suposições Criptográficas	Curvas elípticas, Emparelhamentos	Funções hash resistentes a colisões
Configuração Confiável	Necessária (Plonk etc. são universais)	Não necessária (Transparente)
Resistência Quântica	Não	Sim
Tamanho da Prova	Muito pequeno (~200 Byte)	Um pouco maior (dezenas de KB)
Custo Computacional da Geração da Prova	Alto	Relativamente menor que SNARKs
Custo de Verificação (Taxa de Gas)	Muito baixo (constante)	Baixo (aumenta logaritmicamente)

Nos últimos anos, surgiram SNARKs que “não requerem Configuração Confiável, ou precisam de apenas uma vez”, como Plonk e Halo2, e a fronteira entre SNARKs e STARKs está gradualmente se tornando tênue, mas a diferença fundamental na abordagem matemática é importante.

As Últimas Aplicações de Provas de Conhecimento Zero na Web3 e Segurança

A ZKP, que passou da teoria à prática, está atualmente causando uma revolução na vanguarda da Web3 e da segurança cibernética.

1. Dimensionamento Extremo do Ethereum por ZK-Rollups

As blockchains de camada 1 (L1) como o Ethereum enfrentam grandes limitações de escalabilidade (o trilema) porque enfatizam a descentralização e a segurança. A solução definitiva de camada 2 (L2) para resolver isso é o ZK-Rollups.

No ZK-Rollup, milhares de transações são executadas e processadas off-chain (L2), e uma única “ZKP (Validity Proof)” é gerada para mostrar que todas foram executadas corretamente. O contrato inteligente na cadeia L1 só precisa verificar esta prova.

flowchart LR Users["Users (Envio de Tx)"] --> Sequencer["Sequencer (Coleta e Execução de Tx)"] Sequencer --> Prover["Prover (Geração de ZKP)"] Sequencer --> L1Contract["L1 Smart Contract (Publicação de Dados de Tx)"] Prover --> L1Contract["Submissão de ZKP (Prova)"] L1Contract --> Verify["Verificação & Atualização de Estado"]

A maior vantagem do ZK-Rollups é que, diferentemente do Optimistic Rollups (como Arbitrum ou Optimism), não há necessidade de um período de contestação (geralmente 7 dias) para provas de fraude (Fraud Proof). Como a correção é garantida criptograficamente, a retirada de fundos (Finality) para a L1 é concluída no momento em que a prova é verificada. Atualmente, projetos como zkSync, Starknet, Scroll e Polygon zkEVM estão em intensa competição de desenvolvimento, e a realização do zkEVM, que é compatível com o EVM (Ethereum Virtual Machine), está impulsionando o rápido crescimento do ecossistema.

2. Identidade com Preservação de Privacidade (ZKP for Identity)

A forma como a autenticação pessoal funciona no mundo digital também mudará fundamentalmente com a ZKP. Por exemplo, para a pergunta “Você tem 18 anos ou mais?”, os sistemas tradicionais exigiam a apresentação de uma carteira de motorista ou passaporte, entregando informações pessoais desnecessárias como nome e endereço à outra parte.

Usando ZKP, é possível provar apenas o fato matematicamente de que “com base na minha data de nascimento, tenho 18 anos ou mais na data atual” utilizando certificados digitais emitidos por órgãos governamentais (Verifiable Credential). O verificador só precisa validar a assinatura do certificado e a ZKP, e não pode saber a data de nascimento ou a identidade do usuário.

Projetos de Prova de Humanidade (Proof of Personhood) como o Worldcoin também não armazenam ou compartilham diretamente os dados da íris, mas usam a ZKP para implementar um sistema que comprova “apenas ser um ser humano único”.

3. Contratos Inteligentes Confidenciais e Uso Corporativo

A natureza de “todos os dados serem públicos” nas blockchains públicas sempre foi uma barreira importante para as empresas lidarem com transações confidenciais ou informações da cadeia de suprimentos na blockchain.

Utilizando a tecnologia ZKP (por exemplo, redes focadas em privacidade como Aleo e Aztec), é possível registrar na blockchain pública apenas a validade da atualização do estado, mantendo os valores de entrada e saída das transações e até mesmo a própria lógica do contrato inteligente executado criptografados. Isto possibilita prevenir o front-running (MEV) em DeFi (Finanças Descentralizadas) e construir redes de consórcio confidenciais entre empresas, enquanto se desfruta da alta segurança da blockchain pública.

Desafios Futuros e Perspectivas da ZKP

A ZKP é inegavelmente uma tecnologia fundamental da próxima geração, mas ainda restam alguns desafios.

Custo Computacional da Geração de Provas e Aceleração de Hardware A geração da ZKP requer enormes cálculos de polinômios, FFT (Transformada Rápida de Fourier) e MSM (Multiplicação Multi-Escalar). Atualmente, a pesquisa em hardware especializado (FPGA e ASIC) para acelerar essa geração de provas, conhecida como Mineração ZKP (Prover Network), está avançando rapidamente.
Padronização e Melhoria da Experiência do Desenvolvedor (DX) Múltiplas linguagens dedicadas para escrever circuitos ZKP, como Circom, Cairo, Noir, Leo, estão proliferando. O padrão que as unifica e a maturidade de compiladores que gerem automaticamente circuitos ZKP a partir de Rust ou C++ existentes serão a chave para a adoção da ZKP por engenheiros de software comuns.

Conclusão

As Provas de Conhecimento Zero (ZKP) evoluíram de ser apenas uma “tecnologia para aumentar o anonimato das criptomoedas” para uma “tecnologia de propósito geral que redefine a confiança (trust) de toda a Internet”. As pequenas provas calculadas nas profundezas da matemática e da teoria da criptografia expandem infinitamente a escalabilidade da blockchain e funcionam como um forte escudo para proteger nossa privacidade.

Rumo à verdadeira adoção em massa da Web3 e à construção de uma Internet de próxima geração segura e privada, as Provas de Conhecimento Zero continuarão a funcionar como a peça mais importante. Não podemos tirar os olhos da futura evolução da tecnologia ZKP.

Referências e Links Relacionados

Groth, J. (2016). “On the Size of Pairing-based Non-interactive Arguments”
Ben-Sasson, E., et al. (2018). “Scalable, transparent, and post-quantum secure computational integrity”
Vitalik Buterin’s blog on zk-SNARKs and zk-STARKs

A Hipótese de Riemann e a Distribuição dos Números Primos: A Profunda Relação com a Criptografia Moderna

Fri, 11 Sep 2026 16:00:00 +0900

1. Introdução: O Mistério Cósmico dos Números Primos e a Hipótese de Riemann

Os “Números Primos” (Prime Numbers) são números naturais divisíveis apenas por 1 e por si mesmos, sendo frequentemente chamados de “átomos” do mundo da matemática. Essa sequência que segue como 2, 3, 5, 7, 11, 13… parece, à primeira vista, desordenada e aleatória. Desde que o matemático grego antigo Euclides provou que “os números primos são infinitos”, incontáveis matemáticos têm tentado desvendar os padrões ocultos nessa disposição de primos.

Aquele que chegou mais perto de desvendar esse mistério dos números primos foi o matemático alemão Bernhard Riemann, que propôs a “Hipótese de Riemann” (Riemann Hypothesis) em 1859. A Hipótese de Riemann é um dos problemas mais importantes e não resolvidos da matemática moderna, com um prêmio de 1 milhão de dólares oferecido pelo Instituto de Matemática Clay como um dos Problemas do Prêmio Millennium.

À primeira vista, pode parecer que esse problema formidável da matemática pura sobre a distribuição de números primos não tenha relação com o nosso dia a dia. No entanto, a segurança da internet, que sustenta a infraestrutura da sociedade moderna, especialmente as tecnologias de criptografia modernas como a criptografia RSA e a criptografia de curva elíptica (ECC), depende profundamente das propriedades de números primos gigantescos.

Neste artigo, faremos uma jornada matemática partindo da distribuição dos números primos até o Teorema dos Números Primos, a função zeta de Riemann e o núcleo da Hipótese de Riemann, explorando de forma extremamente detalhada e profunda como isso se conecta com a criptografia moderna e o que aconteceria com o mundo se a Hipótese de Riemann fosse provada.

2. O Teorema dos Números Primos e a Distribuição de Primos: A Descoberta de Gauss

Para entender como os números primos estão distribuídos, os matemáticos conceberam a função de contagem de números primos (Prime-counting function) $\pi(x)$, que representa “quantos números primos existem menores ou iguais a um dado número $x$”.

Por exemplo:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

O gênio matemático de 15 anos, Carl Friedrich Gauss, calculou extensas tabelas de números primos e descobriu que a frequência de aparecimento dos números primos diminui de forma inversamente proporcional ao logaritmo natural $\ln x$. Em outras palavras, ele conjecturou que a probabilidade de encontrar um número primo perto de um número $x$ é de aproximadamente $\frac{1}{\ln x}$.

Expressando isso por meio de uma integral, obtemos o logaritmo integral (Logarithmic integral) $\text{Li}(x)$.

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

A conjectura de Gauss foi posteriormente provada de forma independente por Jacques Hadamard e Charles Jean de la Vallée Poussin em 1896, estabelecendo-se como o Teorema dos Números Primos (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

Ou, de forma aproximada, pode ser expresso como:

$$ \pi(x) \sim \frac{x}{\ln x} $$

Este teorema mostrou que, de uma perspectiva macroscópica, os números primos têm uma distribuição muito suave e previsível. No entanto, microscopicamente, sempre existe um “erro”, ou seja, uma “flutuação” entre $\pi(x)$ e $\text{Li}(x)$. A verdadeira natureza dessa flutuação é exatamente o maior mistério que a Hipótese de Riemann tenta desvendar.

3. A Função Zeta de Riemann e o Produto de Euler

A arma mais poderosa para analisar a distribuição dos números primos é a Função Zeta de Riemann (Riemann Zeta Function). Originalmente, era uma série infinita definida por Leonhard Euler para números reais $s > 1$.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

Uma das maiores conquistas de Euler foi provar que esta série infinita pode ser expressa como um produto infinito sobre todos os números primos $p$. Este é o Produto de Euler (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

Uma compreensão intuitiva da prova é que, se expandirmos cada termo do lado direito como uma série geométrica e os multiplicarmos, o Teorema Fundamental da Aritmética (que afirma que todo número natural pode ser expresso de forma única como um produto de primos) reconstrói perfeitamente a soma dos recíprocos dos números naturais no lado esquerdo.

Essa única equação se tornou a ponte que liga a análise (séries infinitas, funções contínuas) à teoria dos números (números primos, números discretos). Estudar a função zeta é sinônimo de estudar a distribuição dos números primos.

4. Continuação Analítica e a Extensão para o Plano Complexo

A genialidade de Riemann reside no fato de ele ter estendido a variável $s$ de $\zeta(s)$, que Euler considerava apenas para números reais, para números complexos $s = \sigma + it$ ($\sigma$ é a parte real e $t$ é a parte imaginária).

A série infinita original converge apenas para $\sigma > 1$, mas Riemann usou um método chamado “Continuação Analítica (Analytic Continuation)” para estender a definição de modo que $\zeta(s)$ fizesse sentido em todo o plano complexo, com exceção do polo em $s = 1$.

Ele também derivou uma bela equação funcional (Functional equation) que a função zeta satisfaz.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Aqui, $\Gamma(x)$ é a função gama. Com esta equação, podemos conhecer as propriedades do semiplano esquerdo a partir das propriedades do semiplano direito.

Zeros (Zeros of the Zeta Function)

Os números complexos $s$ para os quais o valor da função zeta se torna 0 são chamados de “zeros”. A partir da equação funcional, quando $s$ é um número par negativo ($-2, -4, -6, \dots$), $\sin(\pi s / 2)$ torna-se 0, resultando em $\zeta(s) = 0$. Estes são chamados de zeros triviais (Trivial zeros).

No entanto, o que importa para a distribuição dos números primos são os outros zeros, ou seja, os zeros não triviais (Non-trivial zeros), que existem na “faixa crítica (Critical strip)” onde $0 \le \sigma \le 1$.

5. O Núcleo da Hipótese de Riemann e a Fórmula Explícita

Riemann calculou alguns zeros e formulou uma conjectura surpreendente. Esta é a Hipótese de Riemann.

Hipótese de Riemann (Riemann Hypothesis) Todos os zeros não triviais da função zeta de Riemann $\zeta(s)$ encontram-se na linha reta onde a parte real é igual a $1/2$ ($\text{Re}(s) = 1/2$).

Esta reta onde a parte real é 1/2 é chamada de “linha crítica (Critical line)”.

graph TD A["Função Zeta de Riemann ζ(s)"] --> B["Extensão para o plano complexo via continuação analítica"] B --> C["Zeros triviais (s = -2, -4, -6 ...)"] B --> D["Zeros não triviais (0 <= Re(s) <= 1)"] D --> E["Hipótese de Riemann"] E --> F["Todos os zeros não triviais estão em Re(s) = 1/2"] F --> G["Para a prova do limite do termo de erro da distribuição de primos"]

Por que a Hipótese de Riemann é tão importante? Porque os zeros da função zeta determinam completamente a distribuição dos números primos.

Riemann e o matemático posterior von Mangoldt derivaram a “Fórmula Explícita (Explicit formula)”, que descreve com precisão a distribuição dos números primos. Usando a função de Chebyshev $\psi(x)$, ela pode ser expressa da seguinte forma:

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Aqui, a soma é sobre todos os zeros não triviais $\rho$ da função zeta. O termo principal é $x$ (o que corresponde ao Teorema dos Números Primos), e ao adicionar e subtrair termos ondulatórios que dependem dos zeros $\rho$, a distribuição exata em forma de degraus dos números primos é restaurada. Pode-se dizer que os zeros não triviais representam as “frequências (ondas)” da distribuição dos números primos.

Se a Hipótese de Riemann estiver correta e a parte real de todos os zeros não triviais $\rho$ for exatamente $1/2$, o termo de erro do Teorema dos Números Primos ficará dentro da menor margem teoricamente possível.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

Em outras palavras, se a Hipótese de Riemann for verdadeira, fica provado que os números primos estão distribuídos da forma mais “ordenada e bela” que possamos imaginar.

6. A Relação Inseparável entre a Criptografia Moderna e os Números Primos

Até aqui estivemos no mundo profundo da matemática pura, mas essas propriedades dos números primos sustentam fundamentalmente a sociedade digital moderna. O exemplo mais representativo são os sistemas de criptografia de chave pública, como a criptografia RSA.

A segurança de todas as comunicações, como pagamentos com cartão de crédito na internet, transmissão de senhas e assinaturas digitais em blockchain, depende dos “números primos”.

Como funciona a Criptografia RSA

A segurança da criptografia RSA é baseada no fato matemático (o problema de fatoração de inteiros) de que “a fatoração de um número composto com muitos dígitos é extremamente difícil”.

Geração de Chaves: Escolhem-se aleatoriamente dois números primos gigantescos $p$ e $q$ (por exemplo, de 2048 bits cada). Multiplicam-se ambos para calcular $N = p \times q$. Este $N$ se torna parte da chave pública. Usando a função totiente de Euler $\phi(N) = (p-1)(q-1)$, gera-se a chave privada $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Criptografia e Descriptografia: O texto plano (plaintext) $M$ é convertido em um texto cifrado (ciphertext) $C$ usando a chave pública $e, N$.
$$ C \equiv M^e \pmod{N} $$
Apenas aquele que possui a chave privada $d$ pode descriptografar.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Texto plano (Plaintext)"] --> B["Criptografado com a chave pública (e, N)"] B --> C["Texto cifrado (Ciphertext)"] C --> D["Descriptografado com a chave privada (d)"] D --> E["Texto plano original"] F["Atacante (Attacker)"] -- "Tenta fatorar N" --> C F -.-> G["Sem saber p e q, d é incalculável"]

Para quebrar a criptografia RSA, é necessário encontrar os números primos originais $p$ e $q$ a partir do gigantesco $N$ (fatoração de primos). Mesmo usando os algoritmos predominantes atuais (como o Crivo do Corpo de Números Generalizado: GNFS), diz-se que fatorar um número de centenas de dígitos levaria um tempo que excede muito a idade do universo, mesmo utilizando supercomputadores.

7. O Impacto da Hipótese de Riemann na Criptografia

Então, como a “Hipótese de Riemann”, que está no ápice da matemática pura, cruza-se com a “criptografia”?

7.1. Algoritmos de Geração de Números Primos (Teste de Primalidade) e a Hipótese Generalizada de Riemann (GRH)

Para operar a criptografia RSA, primeiro é necessário gerar os gigantescos números primos $p$ e $q$. No entanto, determinar de forma confiável e rápida “se um determinado número é primo” não é algo simples.

Atualmente, o que é utilizado de forma prática é um algoritmo probabilístico chamado teste de primalidade de Miller-Rabin (Miller-Rabin primality test). Esse algoritmo é rápido, mas carrega o risco de classificar incorretamente, com uma probabilidade extremamente baixa, um número composto como primo, um chamado “pseudoprimo”.

No entanto, assumindo que a “Hipótese Generalizada de Riemann (Generalized Riemann Hypothesis, GRH)”, que estende a Hipótese de Riemann às funções L de Dirichlet, é verdadeira, a história muda drasticamente.

Se a GRH for verdadeira, o limite superior do número de testes no teste de Miller-Rabin será matematicamente garantido, elevando-o de um algoritmo probabilístico para um “algoritmo de tempo polinomial determinístico” (este era um fato crucial já conhecido antes da descoberta do teste de primalidade AKS).

Em outras palavras, a Hipótese de Riemann (e sua generalização) desempenha o papel de dar uma garantia direta para a base da criptografia: “é possível gerar números primos gigantescos de forma rápida e com absoluta confiança?”.

7.2. Relação com os Algoritmos de Fatoração

Ao avaliar a complexidade computacional dos algoritmos usados para decifrar códigos (como o Crivo do Corpo de Números Generalizado), o conhecimento sobre a distribuição dos números primos também é indispensável. A maioria dos algoritmos de fatoração depende da distribuição de “números lisos (Smooth numbers: números que possuem apenas pequenos fatores primos)”.

Para avaliar rigorosamente a frequência com que números lisos aparecem, é necessária uma profunda compreensão da distribuição dos números primos, e aqui também são plenamente utilizadas técnicas de teoria analítica dos números que se conectam diretamente à função zeta e à Hipótese de Riemann. Se a Hipótese de Riemann for provada e o erro na distribuição de primos for completamente determinado, será possível discernir os limites de desempenho dos algoritmos de fatoração de forma mais precisa.

8. Se a Hipótese de Riemann for Provada, a Criptografia será Quebrada?

Assim como uma lenda urbana, às vezes se diz que “se a Hipótese de Riemann for resolvida, a criptografia RSA desmoronará em um instante”, mas isso é matematicamente impreciso.

A prova da Hipótese de Riemann, por si só, não produzirá imediatamente um algoritmo mágico que acelera drasticamente a fatoração. Isso porque a Hipótese de Riemann é, em última análise, um teorema sobre os “padrões de distribuição macroscópicos” dos números primos, e não nos diz diretamente por quais números primos um número específico $N$ é divisível (uma propriedade local).

No entanto, o impacto não é zero. Isso porque é extremamente provável que, no processo de provar a Hipótese de Riemann, “novas ferramentas matemáticas” e “métodos analíticos desconhecidos” sejam descobertos. Olhando para a história, quando o Último Teorema de Fermat ou a Conjectura de Poincaré foram provados, as novas teorias desenvolvidas no processo impulsionaram significativamente a matemática como um todo.

Se for estabelecido um método desconhecido de geometria algébrica ou de geometria não-comutativa capaz de manipular completamente as propriedades dos zeros da função zeta de Riemann, não se pode negar a possibilidade de que isso leve à descoberta de um algoritmo de fatoração revolucionário (por exemplo, um algoritmo clássico que reduz a complexidade para o tempo polinomial). Nesse sentido, os criptógrafos nunca podem tirar os olhos dos desenvolvimentos da Hipótese de Riemann.

Computadores Quânticos e o Algoritmo de Shor

Uma ameaça mais direta e realista à criptografia não é a prova da Hipótese de Riemann, mas os computadores quânticos. O “Algoritmo de Shor”, anunciado por Peter Shor em 1994, provou que, com um computador quântico de capacidade suficiente, a fatoração pode ser resolvida em tempo polinomial. Isso fundamentalmente quebraria a criptografia RSA e a criptografia de curva elíptica.

Atualmente, ao redor do mundo, há uma transição em andamento para a “Criptografia Pós-Quântica (Post-Quantum Cryptography, PQC)” (como a criptografia baseada em reticulados), que não pode ser decifrada nem por computadores quânticos. As tecnologias de criptografia baseadas em números primos podem, de certa forma, estar encerrando sua era de ouro, mas o valor matemático dos números primos em si nunca se perderá.

9. Conclusão: O Cruzamento entre a Abstração da Matemática e o Mundo Real

graph TD A["Exploração da matemática pura"] --> B["Esclarecimento da Hipótese de Riemann"] B --> C["Compreensão completa da distribuição de números primos"] C --> D["Avanço rápido na teoria dos números e geometria algébrica"] D -.-> E["Possibilidade de novos algoritmos de fatoração"] E -.-> F["Atualização na avaliação de segurança da criptografia"] A --> G["Matemática aplicada e ciência da computação"] G --> H["Eficiência no teste de primalidade e geração de códigos"] H --> F

A exploração insaciável dos números primos, que remonta à Grécia Antiga, foi sublimada por um gênio chamado Riemann em uma bela sinfonia no plano complexo (os zeros da função zeta). E, surpreendentemente, esse cristal de matemática pura e inocente foi aplicado séculos depois como o escudo mais forte para garantir a segurança da sociedade da internet.

A Hipótese de Riemann é uma entidade que simboliza, simultaneamente, a “beleza abstrata” e a “incrível aplicabilidade ao mundo físico e à sociedade real” que a matemática possui.

Quando esta montanha colossal da matemática, cujo cume ninguém ainda alcançou, for um dia conquistada, compreenderemos completamente a verdade cósmica dos números primos, e também ganharemos uma nova perspectiva sobre os alicerces da sociedade da informação. Estudar criptografia é, por si só, uma jornada pela história da sabedoria humana.

A História da Criptografia: Da Cifra de César à Criptografia Pós-Quântica (PQC)

Fri, 11 Sep 2026 15:00:00 +0900

1. Introdução: O que é Criptografia?

A criptografia (Cryptography) é uma tecnologia para preservar o sigilo das informações e tem evoluído junto com a história da humanidade. Desde a transmissão de comandos secretos em guerras antigas até a proteção de informações de cartão de crédito na internet moderna, o propósito da criptografia tem sido consistente. Consiste em “garantir que apenas os destinatários pretendidos possam entender as informações e que terceiros não consigam decifrá-las”.

Na segurança da informação moderna, a tecnologia criptográfica não se limita apenas ao “sigilo da informação (Confidencialidade: Confidentiality)”, mas desempenha papéis cruciais como a “Integridade (Integrity)” dos dados, a “Autenticação (Authentication)” e o “Não-repúdio (Non-repudiation)”.

Neste artigo, desvendaremos detalhadamente a história da evolução da tecnologia criptográfica a partir de uma perspectiva técnica e matemática, começando pelas simples cifras de substituição antigas, passando pelas cifras mecânicas, as modernas criptografias de chave simétrica e chave pública, e chegando à era da “Criptografia Pós-Quântica (PQC)” que surge com o uso prático dos computadores quânticos.

2. A Era da Criptografia Clássica: Substituição e Transposição de Letras

As origens da criptografia remontam antes de Cristo. As primeiras cifras consistiam principalmente em duas abordagens: “Transposição (reordenação)” e “Substituição (troca)”.

Cifra de Cítala (Cifra de Transposição)

O “Cítala (Scytale)”, usado em Esparta na Grécia Antiga no século V a.C., é um dos mais antigos instrumentos de criptografia. Uma tira longa e estreita de pergaminho era enrolada em um bastão de madeira de uma espessura específica, e a mensagem era escrita horizontalmente. Ao desenrolar a tira, as letras ficavam ordenadas de forma sem sentido, mas um destinatário com um bastão da mesma espessura poderia enrolar a tira novamente e ler a mensagem original.

Cifra de César (Cifra de Substituição Simples)

Diz-se que o herói romano antigo Júlio César usou a “Cifra de César” no século I a.C. Esta é uma cifra de substituição simples (Monoalphabetic substitution) onde o alfabeto é deslocado por um número fixo (geralmente 3 letras).

Matematicamente, tratando as letras como números de $0$ a $25$ e o número de deslocamentos como $K$, a conversão do texto claro $P$ para o texto cifrado $C$ é expressa pela seguinte equação de congruência:

$$C \equiv P + K \pmod{26}$$

A decodificação realiza a operação inversa.

$$P \equiv C - K \pmod{26}$$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Exemplo simples de implementação da Cifra de César em Python
def caesar_cipher(text, shift, mode="encrypt"):
 result = ""
 if mode == "decrypt":
 shift = -shift

 for char in text:
 if char.isalpha():
 base = ord('A') if char.isupper() else ord('a')
 # Cálculo do deslocamento
 result += chr((ord(char) - base + shift) % 26 + base)
 else:
 result += char
 return result

# Exemplo de execução
plaintext = "HELLO WORLD"
ciphertext = caesar_cipher(plaintext, 3, "encrypt")
print(f"Texto cifrado: {ciphertext}") # KHOOR ZRUOG

Análise de Frequência e Cifra de Vigenère

As cifras de substituição simples tornaram-se facilmente decifráveis através da “Análise de Frequência (Frequency Analysis)”, inventada pelo estudioso árabe Al-Kindi no século IX. Ela se aproveita das propriedades estatísticas da linguagem, onde letras como “E” ou “T” aparecem com frequência, no caso do inglês.

Para combater isso, a “Cifra de Vigenère (Vigenère cipher)” foi concebida no século XVI. Esta é uma cifra de substituição polialfabética (Polyalphabetic substitution) que usa múltiplos deslocamentos (chaves) alternados periodicamente e foi chamada de “cifra indecifrável (Le Chiffre Indéchiffrable)” por cerca de 300 anos.

Matematicamente, a $i$-ésima letra do texto claro $P_i$ e a $i$-ésima letra da chave repetida $K_i$ são usadas para criptografar da seguinte forma:

$$C_i \equiv P_i + K_i \pmod{26}$$

Essa cifra também veio a ser decifrada no século XIX por Charles Babbage e Friedrich Kasiski, através da descoberta do “Exame de Kasiski (Kasiski examination)”, que determina o tamanho da chave a partir de padrões repetitivos no texto cifrado.

graph TD subgraph "Classificação da Criptografia Clássica" A["Criptografia Clássica"] --> B["Cifra de Transposição"] A --> C["Cifra de Substituição"] B --> D["Cifra de Cítala"] C --> E["Substituição Simples"] C --> F["Substituição Polialfabética"] E --> G["Cifra de César"] F --> H["Cifra de Vigenère"] end

3. Criptografia Mecânica e as Guerras Mundiais: Enigma e sua Decodificação

Ao entrarmos no século XX, os meios de comunicação mudaram das cartas para o telégrafo e o rádio, passando a exigir velocidade e complexidade na criptografia. Foi aqui que surgiu a “criptografia mecânica”, combinando rotores (discos rotativos).

A Ameaça da Enigma (Enigma)

A “Enigma”, usada pela Alemanha Nazista durante a Segunda Guerra Mundial, é a máquina de criptografia mais famosa na história da tecnologia criptográfica. A Enigma consistia em múltiplos rotores (geralmente de 3 a 4), um painel de conexões (Steckerbrett) para trocar o cabeamento das letras, e um refletor (rotor reverso).

Como o rotor girava a cada vez que uma letra era digitada no teclado, mesmo que a mesma letra fosse digitada consecutivamente, um caractere cifrado diferente era produzido (o auge da criptografia polialfabética). O seu espaço de chaves (combinações de configurações) chegava a cerca de $1.58 \times 10^{19}$ (aproximadamente 15,8 quintilhões), e com a tecnologia da época, a decodificação por força bruta era considerada impossível.

Alan Turing e a “Bombe (Bombe)”

A equipe de decodificação de códigos de Bletchley Park, no Reino Unido, que se baseou nos resultados iniciais do matemático polonês Marian Rejewski e outros, desafiou essa Enigma inexpugnável.

Particularmente, Alan Turing usou a suposição de texto claro (Crib) correspondente a parte do texto cifrado e desenvolveu a máquina de decodificação eletromecânica “Bombe”. A Bombe detectava rapidamente contradições lógicas e eliminava configurações impossíveis de rotores uma após a outra, obtendo sucesso na decodificação da Enigma. Diz-se que essa grande conquista adiantou a vitória dos Aliados em vários anos.

4. O Início da Criptografia Moderna: Criptografia de Chave Simétrica (DES e AES)

No pós-guerra, com o advento dos computadores, a criptografia passou por uma mudança drástica de paradigma, da manipulação de “letras” para a manipulação de “bits (0 e 1)”.

Claude Shannon e a Teoria da Informação

Em 1949, Claude Shannon publicou o artigo “Teoria da Comunicação de Sistemas Secretos”, estabelecendo os fundamentos matemáticos da criptografia moderna. Ele propôs a “Confusão (Confusion)” e a “Difusão (Diffusion)” como princípios para um design criptográfico seguro.

Confusão (Confusion): Tornar a relação entre a chave e o texto cifrado o mais complexa possível. (Realizado por substituição / S-boxes)
Difusão (Diffusion): Fazer com que a alteração de 1 bit do texto claro afete muitos bits do texto cifrado. (Realizado por transposição / permutação)

DES (Data Encryption Standard)

Em 1977, o Instituto Nacional de Padrões e Tecnologia dos EUA (NIST, então NBS) estabeleceu o “DES”, baseado no design da IBM, como o padrão de criptografia. O DES adota uma arquitetura chamada “Rede de Feistel (Feistel Network)”, possuindo um tamanho de bloco de 64 bits e um tamanho de chave de 56 bits. Havia uma vantagem na implementação onde o algoritmo de criptografia e decodificação possuíam quase a mesma estrutura.

No entanto, à medida que o poder de computação melhorava, tornou-se claro que um tamanho de chave de 56 bits (cerca de $7.2 \times 10^{16}$ possibilidades) era insuficiente. Em 1998, a Electronic Frontier Foundation (EFF) desenvolveu uma máquina dedicada, a “Deep Crack”, e demonstrou a quebra do DES em poucos dias.

AES (Advanced Encryption Standard)

Como um novo padrão para substituir o DES, o “AES” foi estabelecido em 2001. O algoritmo “Rijndael”, criado por criptógrafos belgas selecionado através de um concurso público, foi adotado.

O AES não utiliza a Rede de Feistel, mas sim a “Estrutura SPN (Substitution-Permutation Network)”, e utiliza operações matemáticas sobre o Campo de Galois (campo finito) $GF(2^8)$. O tamanho da chave pode ser selecionado entre 128, 192 e 256 bits, e ainda hoje é amplamente utilizado como o padrão de criptografia de chave simétrica em todo o mundo.

graph TD subgraph "Processo de 1 round do AES (Estrutura SPN)" A["Estado de entrada (128-bit)"] --> B("SubBytes (Substituição de bytes / S-Box)") B --> C("ShiftRows (Deslocamento de linhas)") C --> D("MixColumns (Mistura de colunas / Multiplicação em GF(2^8))") D --> E("AddRoundKey (XOR com a chave da rodada)") E --> F["Para a próxima rodada"] end

5. A Revolução da Criptografia de Chave Pública: De Diffie-Hellman a RSA

A criptografia de chave simétrica possuía uma fraqueza decisiva. Trata-se do “Problema de Distribuição de Chaves (Key Distribution Problem)”. É o problema de como compartilhar de forma segura uma “chave comum” com uma parte distante antes de iniciar a comunicação criptografada. Este problema foi resolvido pela “Criptografia de Chave Pública”, nascida na década de 1970.

Troca de Chaves de Diffie-Hellman

Em 1976, Whitfield Diffie e Martin Hellman publicaram o artigo revolucionário “New Directions in Cryptography”. Eles utilizaram a dificuldade matemática chamada “Problema do Logaritmo Discreto (Discrete Logarithm Problem)” e propuseram um método para compartilhar chaves de forma segura, mesmo em canais de comunicação interceptados.

Um número primo grande $p$ e um gerador $g$ são tornados públicos.
Alice escolhe um valor secreto $a$ e envia $A = g^a \pmod{p}$ para Bob.
Bob escolhe um valor secreto $b$ e envia $B = g^b \pmod{p}$ para Alice.
Alice calcula $K = B^a \pmod{p}$, e Bob calcula $K = A^b \pmod{p}$.
Pelas leis dos expoentes, $K = (g^b)^a = (g^a)^b = g^{ab} \pmod{p}$, e assim, de forma brilhante, eles podem compartilhar a mesma chave $K$.

Criptografia RSA

No ano seguinte, em 1977, a “Criptografia RSA” foi concebida por Ron Rivest, Adi Shamir e Leonard Adleman. Ela baseia-se na propriedade de que “a fatoração de números compostos gigantes é difícil”.

Mecanismo matemático do RSA:

Escolhem-se 2 números primos gigantes $p$ e $q$, e calcula-se $n = p \times q$.
Calcula-se a função totiente de Euler $\phi(n) = (p-1)(q-1)$.
Escolhe-se um número inteiro $e$ (chave pública) que seja coprimo de $\phi(n)$.
Calcula-se um número inteiro $d$ (chave privada) tal que $e \times d \equiv 1 \pmod{\phi(n)}$.

Criptografia: Para o texto claro $M$, $C \equiv M^e \pmod{n}$ Decodificação: Para o texto cifrado $C$, $M \equiv C^d \pmod{n}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# Código Python demonstrando o conceito da criptografia RSA (não para uso prático)
def ext_euclid(a, b):
 # Cálculo do inverso modular pelo algoritmo de Euclides estendido
 if b == 0: return 1, 0, a
 x, y, g = ext_euclid(b, a % b)
 return y, x - (a // b) * y, g

def rsa_example():
 # Exemplo usando números primos pequenos
 p, q = 61, 53
 n = p * q
 phi = (p - 1) * (q - 1)

 e = 17 # Valor coprimo de phi
 d, _, _ = ext_euclid(e, phi)
 if d < 0: d += phi

 print(f"Chave pública: (e={e}, n={n})")
 print(f"Chave privada: (d={d}, n={n})")

 # Criptografia e decodificação de uma mensagem
 message = 65
 ciphertext = pow(message, e, n)
 decrypted = pow(ciphertext, d, n)

 print(f"Texto claro: {message} -> Texto cifrado: {ciphertext} -> Após decodificação: {decrypted}")

rsa_example()

6. A Ascensão da Criptografia de Curva Elíptica (ECC)

A criptografia RSA é forte, mas com a melhoria no desempenho dos computadores, tornou-se necessário aumentar o tamanho da chave para manter a segurança (atualmente 2048 bits ou 3072 bits), o que gerou o problema do aumento do custo computacional.

Portanto, em 1985 foi proposta a “Criptografia de Curva Elíptica (Elliptic Curve Cryptography: ECC)”. Isso utiliza a adição de pontos em uma curva elíptica sobre um campo finito (geralmente na forma de $y^2 = x^3 + ax + b$).

Sabe-se que o Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP) é ainda mais difícil de resolver do que o problema da fatoração de primos, e o ECC pode alcançar a mesma segurança que o RSA de 3072 bits com um tamanho de chave de apenas 256 bits. Isso possibilitou uma comunicação criptografada de alta velocidade e segurança (como ECDSA e ECDH) até mesmo em ambientes com recursos computacionais limitados, como smartphones e dispositivos IoT.

7. A Ameaça dos Computadores Quânticos e a Criptografia Pós-Quântica (PQC)

A tecnologia criptográfica parecia sólida, mas em 1994, o “Algoritmo de Shor” publicado por Peter Shor causou um grande impacto.

Os computadores quânticos realizam cálculos utilizando as propriedades da mecânica quântica de “superposição” e “emaranhamento quântico”. Foi matematicamente provado que a execução do algoritmo de Shor em um computador quântico de desempenho suficiente pode resolver o problema de fatoração de primos e o problema do logaritmo discreto em “tempo polinomial”. Ou seja, no dia em que um computador quântico prático for concluído (Q-Day), as criptografias de chave pública usadas atualmente, como RSA e ECC, serão corrompidas instantaneamente.

O Surgimento da PQC (Post-Quantum Cryptography)

Em preparação para esta ameaça sem precedentes, pesquisas em “Criptografia Pós-Quântica (PQC)”, baseada em novos problemas matemáticos difíceis de resolver mesmo para computadores quânticos, estão avançando a passos largos. O NIST (Instituto Nacional de Padrões e Tecnologia dos EUA) tem conduzido um processo de padronização da PQC ao longo de muitos anos, e as seguintes abordagens matemáticas são consideradas as mais promissoras.

1. Criptografia Baseada em Reticulados (Lattice-based Cryptography)

Atualmente é a abordagem mais promissora, sendo também adotada nos algoritmos de padronização do NIST (ML-KEM / Kyber, ML-DSA / Dilithium). Ela baseia-se na dificuldade de encontrar pontos específicos (como o Problema do Vetor Mais Curto: SVP) em “reticulados (Lattice)” no espaço multidimensional e no problema LWE (Learning With Errors: Aprendizado Com Erros).

O conceito do problema LWE aproveita a propriedade de que se um “pequeno ruído (erro)” for adicionado intencionalmente a um sistema de equações lineares simultâneas, de repente torna-se difícil encontrar a solução. Sistema de equações: $\mathbf{A}\mathbf{s} + \mathbf{e} \equiv \mathbf{b} \pmod{q}$ ($\mathbf{A}$ e $\mathbf{b}$ são públicos, $\mathbf{s}$ é a chave privada, $\mathbf{e}$ é o ruído minúsculo)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# Pseudo-código conceitual do problema LWE (Para fins educacionais)
import numpy as np

n = 256 # Dimensão
q = 3329 # Módulo
m = 512 # Número de equações

# Chave privada s e pequeno erro e
s = np.random.randint(0, 5, size=n)
e = np.random.randint(-1, 2, size=m)

# Matriz pública A e vetor público b
A = np.random.randint(0, q, size=(m, n))
b = (np.dot(A, s) + e) % q

# Mesmo utilizando um computador quântico, é considerado extremamente difícil recuperar s a partir de A e b

2. Criptografia Baseada em Hash (Hash-based Cryptography)

É um esquema de assinatura digital que baseia a sua segurança unicamente na resistência a colisões de funções hash. Por não possuir uma estrutura matemática, é forte contra ataques quânticos, mas tende a ter tamanhos de assinatura grandes (como SPHINCS+).

3. Criptografia Baseada em Código (Code-based Cryptography)

É um sistema criptográfico baseado na teoria de códigos de correção de erros. A Criptografia de McEliece, proposta em 1978, é famosa; possui uma longa história e uma segurança estabelecida, mas tem o desafio de que o tamanho da chave pública é extremamente grande (podendo chegar a vários megabytes).

timeline title "História da Evolução da Criptografia e dos Computadores" "Antiguidade - Idade Média" : "Cifra de César" : "Cifra de Vigenère" : "Nascimento da Análise de Frequência" "Anos 1930 - 1940" : "Operação e Decodificação da Enigma" : "Máquina de Turing - Desenvolvimento da Bombe" "Anos 1970" : "Padronização do DES (1977)" : "Troca de Chaves de Diffie-Hellman (1976)" : "Nascimento da Criptografia RSA (1977)" "Anos 1980 - 1990" : "Proposta da Criptografia de Curva Elíptica (ECC)" : "Publicação do Algoritmo de Shor (1994)" "Anos 2000" : "Padronização do AES (2001)" "Anos 2010 - Atualidade" : "Aceleração da Pesquisa em Computadores Quânticos" : "Início do Projeto de Padronização PQC pelo NIST" "Futuro Próximo (Q-Day)" : "Realização do Computador Quântico em Larga Escala?" : "Transição Completa para PQC (ML-KEM/ML-DSA)"

8. Conclusão: Uma Batalha Interminável de Escudos e Lanças

A história da tecnologia criptográfica é a história de uma batalha interminável entre a invenção de novos esquemas de criptografia (escudos) e os novos métodos de decodificação que os quebram (lanças).

A Cifra de César foi derrotada pela análise de frequência, e a outrora invencível Enigma foi derrotada pelo gênio de Turing e o poder das máquinas. E agora, as fortes criptografias como RSA e ECC, que sustentam as bases da sociedade moderna da internet, estão sob a ameaça da nova “lança”, que é o computador quântico.

No entanto, a humanidade já vislumbra o futuro e está se preparando para o novo “escudo”, a Criptografia Pós-Quântica (PQC). Atualmente, as preparações para a transição (Garantia de Agilidade Criptográfica - Crypto Agility) das criptografias de chave pública existentes para a PQC em infraestruturas de TI ao redor do mundo são uma questão de urgência.

A tecnologia criptográfica não é apenas um quebra-cabeça matemático obscuro, mas sim a barreira mais forte para proteger nossa privacidade, nossas propriedades e as próprias infraestruturas da sociedade.

【Explicação de Matemática】Explicando o mecanismo da criptografia RSA para que até alunos do ensino médio entendam

Fri, 11 Sep 2026 13:00:00 +0900

Uma das tecnologias que sustenta a segurança da nossa sociedade baseada na internet desde a sua base é a “Criptografia RSA”. Muitas das comunicações que usamos casualmente todos os dias, como pagamentos com cartão de crédito em compras online, troca de mensagens em redes sociais com amigos, ou o envio e recebimento de informações confidenciais de empresas, são protegidas pela criptografia RSA e suas tecnologias sucessoras.

No entanto, ao ouvir a palavra “criptografia”, você pode imaginar máquinas de cifra complexas como as que aparecem em filmes de espionagem, ou uma matemática super avançada que apenas alguns gênios conseguem entender. É verdade que a teoria criptográfica moderna é baseada em matemática avançada, mas o mecanismo fundamental da criptografia RSA pode ser plenamente compreendido com o conhecimento de matemática ensinado no ensino médio (propriedades de números inteiros, números primos, congruências, etc.).

Neste artigo, usaremos o conhecimento da matemática do ensino médio como ponto de partida para explicar passo a passo e de forma aprofundada os princípios matemáticos pelos quais a criptografia RSA funciona e por que é tão difícil de quebrar. Explicarei cuidadosamente usando exemplos concretos para que mesmo aqueles que têm um pouco de dificuldade com matemática possam entender.

1. Criptografia de Chave Simétrica e Criptografia de Chave Pública

Antes de mergulhar no mecanismo matemático da criptografia RSA, vamos primeiro revisar a ideia básica de criptografia. Os métodos criptográficos podem ser amplamente divididos em dois tipos: “Criptografia de chave simétrica” e “Criptografia de chave pública”.

1.1 Limitações da Criptografia de Chave Simétrica

Muitos dos métodos de criptografia usados há muito tempo são chamados de “Criptografia de chave simétrica”. Este é um método em que a mesma chave é usada tanto para “criptografia” (converter uma mensagem em um texto cifrado secreto) quanto para “descriptografia” (retornar o texto cifrado à mensagem original).

Por exemplo, suponha que a Alice vá enviar uma carta secreta ao Bob. A Alice coloca a carta em uma caixa e a tranca usando um cadeado (chave simétrica). Para o Bob abrir essa caixa, ele precisará ter a mesma chave que a Alice usou.

Este método tem um grande problema: o “Problema de distribuição de chaves”. Quando Alice e Bob, que estão distantes, se comunicam pela primeira vez, como eles poderiam compartilhar a chave sem serem interceptados? Se a chave for roubada por terceiros enquanto é enviada por correio, toda a comunicação criptografada subsequente ficará totalmente exposta.

1.2 Uma Invenção Revolucionária: “Criptografia de Chave Pública”

A “Criptografia de chave pública” foi idealizada para resolver esse problema de distribuição de chaves. A criptografia RSA é um tipo deste sistema.

Na criptografia de chave pública, usamos duas chaves diferentes: uma “chave para criptografar (chave pública)” e uma “chave para descriptografar (chave privada)”.

O destinatário, Bob, cria um par de “chave pública” e “chave privada”.
Bob publica a “chave pública” para todo o mundo (não importa quem a obtenha).
A remetente, Alice, criptografa a mensagem usando a “chave pública” de Bob e a envia.
A mensagem criptografada só pode ser descriptografada com a “chave privada” que apenas Bob possui.

Comparando isso com o exemplo do cadeado: Bob cria vários “cadeados abertos (chaves públicas)” e os distribui pelo mundo. Alice coloca sua mensagem destinada a Bob em uma caixa e a tranca fechando um dos cadeados que encontrou pertencente a Bob. Uma vez que o cadeado é fechado, ele só pode ser aberto com a “chave mestra (chave privada)” que Bob possui. Mesmo que alguém roube a caixa no meio do caminho, essa pessoa não conseguirá abri-la porque não tem a chave mestra.

graph TD A["Alice (Remetente)"] --> B["Texto Plano (Mensagem)"] B --> C["Processo de Criptografia"] D["Chave Pública do Bob (Disponível para qualquer um)"] --> C C --> E["Enviado via Internet: Texto Cifrado"] E --> F["Processo de Descriptografia"] G["Chave Privada do Bob (Mantida apenas pelo Bob)"] --> F F --> H["Texto Plano Restaurado (Mensagem)"] H --> I["Bob (Destinatário)"]

Para implementar este sistema revolucionário, é necessária algum tipo de “função unidirecional (um quebra-cabeça matemático de mão única)”, que significa que “é fácil criptografar com a chave pública, mas é absolutamente impossível descriptografar sem a chave privada”. Como peça para esse quebra-cabeça, a atenção se voltou para os “números primos”, algo que conhecemos bem.

2. Base Matemática 1 Sustentando a Criptografia RSA: Números Primos e Fatoração em Números Primos

A segurança da criptografia RSA é baseada no fato matemático de que “a fatoração de números gigantes em números primos é extremamente difícil”.

2.1 O que são Números Primos?

Os números primos são “números naturais maiores que 1 que só podem ser divididos por 1 e por si mesmos”. Exemplo: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Os números primos são como “átomos” para todos os números inteiros. Qualquer número natural pode ser decomposto na forma de uma multiplicação de números primos. Isso é chamado de fatoração em números primos. Por exemplo, como em $60 = 2^2 \times 3 \times 5$, ignorando a ordem, o fato de que pode ser fatorado em números primos de apenas uma única forma é conhecido como o “Teorema Fundamental da Aritmética”.

2.2 A Dificuldade da Fatoração em Números Primos (Função Unidirecional)

O importante aqui é a assimetria: “A multiplicação é fácil, mas a fatoração em números primos é difícil”.

Por exemplo, tente calcular de cabeça a multiplicação destes dois números primos: $11 \times 13 = ?$ Isto é fácil. A resposta é $143$.

Então, que tal o próximo número? Por favor, fatore $323$ em números primos. E então? Deve demorar um pouco. (A resposta é $17 \times 19$).

Quando os números são pequenos, até humanos conseguem calcular de alguma forma, mas quando os números ficam grandes, o cálculo se torna explosivamente difícil, mesmo usando computadores. Na criptografia RSA moderna, usamos um número $N = p \times q$ obtido pela multiplicação de números primos incrivelmente gigantes $p$ e $q$ de 2048 bits (cerca de 600 dígitos decimais).

Quando fornecidos dois números primos gigantes $p$ e $q$, calcular $N$ leva apenas um instante (menos de um milissegundo) para um computador. No entanto, reversamente, receber apenas $N$ e encontrar os $p$ e $q$ originais leva tanto tempo que não seria resolvido mesmo rodando os supercomputadores mais rápidos da atualidade por trilhões de anos.

Essa “assimetria computacional (um caminho é fácil, o caminho inverso é difícil)” é a base que cria o relacionamento entre a chave pública e a chave privada.

3. Base Matemática 2 Sustentando a Criptografia RSA: Congruência (Aritmética Modular)

Os cálculos da criptografia RSA não são realizados com adição e multiplicação onde os números ficam infinitamente grandes, como costumamos usar, mas sim no mundo dos “restos” quando divididos por um certo número. Isso é chamado de congruência (aritmética modular).

3.1 A Matemática do Relógio

A aritmética modular é frequentemente comparada com a “matemática do relógio”. Supondo que agora são 10 horas, que horas serão daqui a 5 horas? $10 + 5 = 15$ horas, mas em um relógio normal de 12 horas, respondemos “3 horas”. Isso ocorre porque o resto de 15 dividido por 12 é 3.

No mundo da matemática, isso é escrito da seguinte forma:

$$ 15 \equiv 3 \pmod{12} $$

Lê-se “15 e 3 são congruentes módulo 12 (os restos quando divididos por 12 são iguais)”.

3.2 Propriedades Básicas da Congruência

A congruência possui propriedades muito úteis e semelhantes a equações (igualdades $=$). Vamos assumir que o módulo (número pelo qual dividimos) é $N$. Quando $a \equiv b \pmod N$ e $c \equiv d \pmod N$, o seguinte é verdadeiro:

Adição: $a + c \equiv b + d \pmod N$
Subtração: $a - c \equiv b - d \pmod N$
Multiplicação: $a \times c \equiv b \times d \pmod N$
Exponenciação: $a^k \equiv b^k \pmod N$ ($k$ é um número natural)

Particularmente importante é a propriedade da “exponenciação”. Isso significa que “o resto de uma potência é igual à potência do resto”. Por exemplo, imagine que você queira encontrar o resto de $7^{100}$ dividido por $5$. Seria muito difícil multiplicar o $7$ por ele mesmo 100 vezes e depois dividir por $5$, mas se usarmos a propriedade da congruência, como $7 \equiv 2 \pmod 5$, então $7^{100} \equiv 2^{100} \pmod 5$, permitindo simplificar drasticamente o cálculo. No mundo da criptografia lidamos com potências de números extremamente grandes, então essa propriedade é indispensável.

4. Base Matemática 3 Sustentando a Criptografia RSA: Função de Euler e Teorema de Euler

A partir daqui, entra a matemática mágica que forma o núcleo da criptografia RSA. Apresentamos o “Teorema de Euler”, que é uma generalização do “Pequeno Teorema de Fermat”.

4.1 A Função Totiente de Euler $\phi(N)$

A função totiente de Euler (função $\phi$) é uma função que, para um determinado número natural $N$, retorna “a quantidade de números naturais de 1 até $N$ que são coprimos de $N$ (ou seja, seu máximo divisor comum é 1)”.

Vamos olhar alguns exemplos.

$\phi(5)$: Dentre 1, 2, 3, 4, 5, os números coprimos de 5 são 1, 2, 3, 4; ou seja, 4 números. Portanto, $\phi(5) = 4$.
$\phi(6)$: Dentre 1, 2, 3, 4, 5, 6, os números coprimos de 6 são 1, 5; ou seja, 2 números. Portanto, $\phi(6) = 2$.

[Propriedade especial no caso de números primos] Quando $p$ é um número primo, todos os números de 1 até $p-1$ são coprimos de $p$. Logo,

$$ \phi(p) = p - 1 $$

[Propriedade especial no caso de um produto de números primos] Para dois números primos distintos $p$ e $q$, quando se estabelece que $N = p \times q$, $\phi(N)$ pode ser facilmente obtido pelo seguinte cálculo:

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Essa propriedade funciona como a “porta dos fundos secreta (alçapão)” na criptografia RSA. Alguém que conhece $p$ e $q$ (o criador das chaves) pode calcular $\phi(N)$ em um instante, mas um terceiro que conhece apenas $N$ não pode determinar $\phi(N)$ a menos que fatore $N$ em números primos.

4.2 Teorema de Euler

Leonhard Euler usou esse $\phi(N)$ para provar o seguinte belo teorema.

Teorema de Euler: Quando um inteiro $a$ e $N$ são coprimos, a seguinte congruência é verdadeira:

$$ a^{\phi(N)} \equiv 1 \pmod N $$

Isso é uma propriedade surpreendente que diz: “quando você multiplica um certo número $a$ por ele mesmo $\phi(N)$ vezes e divide por $N$, o resto será sempre $1$”. (Se $N$ for um número primo $p$, torna-se $a^{p-1} \equiv 1 \pmod p$, que é chamado de Pequeno Teorema de Fermat).

Vamos transformar este Teorema de Euler. Multiplicamos ambos os lados por $a$ mais uma vez.

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

Além disso, para qualquer número inteiro $k$, $a^{k \cdot \phi(N)}$ também será $1^k = 1$, de modo que a seguinte fórmula é válida:

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

Esta exata equação é o princípio fundamental que faz com que a mágica da criptografia RSA de “retornar ao original quando descriptografada após criptografar” funcione.

5. Algoritmo da Criptografia RSA: Passos para Geração de Chaves, Criptografia e Descriptografia

Agora que temos o conhecimento básico, vamos olhar para os passos concretos da criptografia RSA. A criptografia RSA é dividida principalmente em três fases: “1. Geração de Chaves”, “2. Criptografia” e “3. Descriptografia”.

flowchart TD A1["1. Escolher os primos p, q"] --> A2["Calcular N = p × q"] A1 --> A3["Calcular φ(N) = (p-1)(q-1)"] A3 --> A4["Escolher e coprimo de φ(N)"] A3 --> A5["Calcular d tal que e × d ≡ 1 (mod φ(N))"] A2 --> A6["Chave Pública (N, e)"] A4 --> A6 A5 --> A7["Chave Privada d"] B1["2. Mensagem em Texto Plano M"] --> B2["Calcular C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Enviar Texto Cifrado C"] B3 --> C1["3. Receber Texto Cifrado C"] C1 --> C2["Calcular M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Obter a Mensagem em Texto Plano original M"]

5.1 Geração de Chaves (Key Generation)

Bob, o destinatário, gera sua “chave pública” e “chave privada”.

Seleção dos primos: Ele escolhe dois grandes números primos $p$ e $q$ aleatoriamente.
Cálculo do módulo $N$: Ele calcula $N = p \times q$. Este $N$ é tornado público.
Cálculo de $\phi(N)$: Ele calcula a função de Euler $\phi(N) = (p - 1)(q - 1)$. Este número é um segredo apenas do Bob.
Seleção da chave pública $e$: Ele escolhe um inteiro $e$ tal que $1 < e < \phi(N)$ e que $e$ seja coprimo de $\phi(N)$.
Cálculo da chave privada $d$: Ele encontra um inteiro $d$ que satisfaça a seguinte condição: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Isso significa “um número $d$ tal que, quando $e \times d$ é dividido por $\phi(N)$, o resto é $1$”.

Com isso, as chaves estão prontas.

Chave Pública: O par $(N, e)$. Publicado para todo o mundo.
Chave Privada: $d$. Jamais revelado a ninguém.

5.2 Criptografia (Encryption)

Suponha que Alice queira enviar uma mensagem secreta $M$ para Bob. (Assumimos que $M$ é um texto convertido em valor numérico, e que $0 \le M < N$). Alice usa a chave pública do Bob, $(N, e)$, para fazer o seguinte cálculo:

$$ C \equiv M^e \pmod N $$

Ela calcula “o resto $C$ obtido após elevar a mensagem $M$ à potência de $e$, e dividir por $N$”. Esse $C$ é o texto cifrado.

5.3 Descriptografia (Decryption)

Bob recebe o texto cifrado $C$. Bob usa sua chave privada $d$ para calcular o seguinte:

$$ M \equiv C^d \pmod N $$

Ao calcular “o resto de elevar o texto cifrado $C$ à potência de $d$, e dividir por $N$”, incrivelmente a mensagem original $M$ é restaurada!

6. Por que retorna ao original na descriptografia? (Prova Matemática)

Você pode se perguntar: “Por que simplesmente elevar $C$ à potência de $d$ retorna ao $M$ original?”. Aqui, o “Teorema de Euler” mencionado anteriormente mostra o seu poder.

Vamos substituir a equação de criptografia $C = M^e$ na equação de descriptografia $C^d \pmod N$.

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Aqui, lembre-se do Passo 5 da Geração de Chaves. Ao criar $d$, Bob o escolheu de forma que $e \times d \equiv 1 \pmod{\phi(N)}$. Isso significa que “$ed$ é um múltiplo de $\phi(N)$ somado a $1$”. Podemos escrevê-lo da seguinte maneira, utilizando um inteiro $k$:

$$ ed = k \cdot \phi(N) + 1 $$

Substituímos isso no expoente e o decompomos usando as leis dos expoentes:

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

Aqui, assumindo que a mensagem $M$ e $N$ são coprimos, a partir do Teorema de Euler, temos $M^{\phi(N)} \equiv 1 \pmod N$.

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

Portanto, a seguinte equação é perfeitamente estabelecida:

$$ C^d \equiv M \pmod N $$

Como a Alice não conhece $d$, e o espião também não conhece $d$, apenas Bob, que possui $d$, consegue extrair o $M$ a partir de $C$.

7. Exemplo Concreto: Vamos vivenciar o RSA calculando à mão usando pequenos números primos

Vamos tentar enviar uma comunicação criptografada de Alice para Bob usando números pequenos (números primos) de fato.

[Fase de Geração de Chaves do Bob]

Escolhe-se dois números primos $p=11$, $q=13$.
Calcula-se $N = 11 \times 13 = 143$.
Calcula-se $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Escolhe-se uma chave pública $e$ coprima de $\phi(N)=120$. Aqui usaremos $e=7$.
Calcula-se a chave privada $d$. Buscamos um $d$ que satisfaça $7 \times d \equiv 1 \pmod{120}$. Na equação $7d = 120k + 1$, quando $k=6$, temos $721$, e $721 \div 7 = 103$. Portanto, $d = 103$.

Chave Pública: $(N=143, e=7)$
Chave Privada: $d=103$

[Fase de Criptografia da Alice] Suponha que ela queira enviar a mensagem $M = 9$. Fórmula: $C \equiv 9^7 \pmod{143}$ $9^7 = 4.782.969$. Dividindo isso por 143, dá $33447$ com resto $48$. O texto cifrado se tornou $C = 48$.

[Fase de Descriptografia do Bob] Bob recebe o texto cifrado $C = 48$ e o descriptografa usando a chave privada $d = 103$. Fórmula: $M \equiv 48^{103} \pmod{143}$ Se executarmos (48 ** 103) % 143 na calculadora, brilhantemente o resultado será “9”! A mensagem original foi recebida com sucesso.

8. Como encontrar a Chave Privada $d$: Algoritmo de Euclides Estendido

No exemplo calculado à mão, adivinhamos o valor de $k$ para encontrar $d=103$, mas quando o número atinge centenas de dígitos, esse método se torna impossível. Nos programas reais usamos um algoritmo chamado “Algoritmo de Euclides Estendido”.

Resolver $7d \equiv 1 \pmod{120}$ é o mesmo que encontrar inteiros $d, y$ que satisfaçam $7d + 120y = 1$. Ao realizar os passos do Algoritmo de Euclides ao reverso, podemos encontrar isso mecanicamente.

$120 \div 7 = 17$ com resto $1$
Rearranjando isso, temos $1 = 120 - 17 \times 7$
Em outras palavras, $-17 \times 7 \equiv 1 \pmod{120}$

No mundo do módulo $120$, $-17$ tem o mesmo significado que $120 - 17 = 103$. Assim, o $d = 103$ pode ser encontrado em um instante. Este método consegue calcular de forma extremamente rápida por mais gigante que o número seja.

9. Outra Face da Criptografia RSA: Assinatura Digital

A parte fantástica da criptografia RSA é que, se invertermos as funções da chave pública e chave privada, ela também pode ser usada como uma “Assinatura Digital”.

Na criptografia os passos eram: “Criptografar com a chave pública $\Rightarrow$ Descriptografar com a chave privada”, Mas na assinatura digital seguimos os passos: “Criptografar com a chave privada $\Rightarrow$ Descriptografar com a chave pública”.

flowchart TD A1["1. Alice cria a assinatura com a chave privada"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Envia a mensagem M e a assinatura S"] A3 --> B1["2. Bob verifica a assinatura com a chave pública"] B1 --> B2["Calcula M' ≡ S^e (mod N)"] B2 --> B3["Verifica se M' e M coincidem"]

A Alice transforma a mensagem usando sua própria chave privada $d$ (essa será a assinatura $S$) e envia ao Bob. O Bob faz o cálculo de verificação usando a chave pública de Alice, $e$. Se o resultado do cálculo for igual à mensagem original, isso prova simultaneamente que “os dados só poderiam ter sido criados pela chave privada da Alice” e que “a mensagem não foi adulterada no meio do caminho”.

10. Sentindo a Criptografia RSA na Prática com Código

O cálculo de potências que seria difícil de fazer à mão pode ser implementado muito facilmente usando Python. A seguir, um código Python para você experienciar a lógica central da criptografia RSA.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """Calcular o máximo divisor comum"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Encontrar a chave privada d (usando a função embutida a partir do Python 3.8)"""
 return pow(e, -1, phi)

# 1. Geração de chaves
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Chave Pública: (N={N}, e={e}), Chave Privada: d={d}")

# 2. Criptografia
message = 9
ciphertext = pow(message, e, N)
print(f"Texto Cifrado: {ciphertext}")

# 3. Descriptografia
decrypted_message = pow(ciphertext, d, N)
print(f"Mensagem Descriptografada: {decrypted_message}")

Como a função pow(base, exp, mod) do Python usa internamente um algoritmo rápido chamado “exponenciação binária (ou método das multiplicações repetidas)”, o cálculo termina em um instante mesmo para números com centenas de dígitos.

11. Conclusão e Futuro das Tecnologias de Criptografia

Nós desvendamos o mecanismo da criptografia RSA tendo como base a matemática do ensino médio.

A dificuldade da fatoração em números primos: É fácil calcular $p \times q = N$, mas é extremamente difícil encontrar $p, q$ a partir de $N$.
Congruências e Teorema de Euler: Devido à regra $a^{\phi(N)} \equiv 1 \pmod N$, completa-se o mágico alçapão onde “a exponenciação por um certo número retorna ao estado original”.
Chave Pública e Chave Privada: Qualquer um pode criptografar, mas apenas o destinatário legítimo consegue descriptografar.

O $N$ da criptografia RSA usada atualmente possui mais de 600 dígitos, e mesmo que todos os supercomputadores do mundo se juntassem para faturar esse número em primos, levaria um tempo maior do que a idade do universo. No entanto, se o “computador quântico”, que vem sendo pesquisado ativamente nos últimos anos, se tornar prático no futuro, essa fatoração poderá ser resolvida em instantes pelo “Algoritmo de Shor”. Por esse motivo, criptografias “resistentes a computadores quânticos”, que não poderiam ser quebradas nem mesmo por eles, estão sendo desenvolvidas a um ritmo acelerado pelo mundo todo.

A matemática avançada que costumamos considerar “inútil”, na verdade, protege nosso dia a dia na sua essência mais profunda. A criptografia RSA é um excelente material didático que nos ensina essa profundidade e beleza da matemática. Ficaria muito feliz se através deste artigo você pudesse sentir um pouco do fascínio da criptografia e da matemática.

O que é a Criptografia Totalmente Homomórfica (FHE)? Explicando a essência da segurança de próxima geração

Fri, 11 Sep 2026 11:00:00 +0900

À medida que a computação em nuvem e a tecnologia de IA se estabelecem como base da sociedade, o trade-off entre a “privacidade de dados” e a “utilização de dados” tornou-se um dos desafios mais importantes. Embora haja uma demanda crescente por ter IAs analisando dados altamente sensíveis na nuvem — como dados médicos, informações financeiras e dados biométricos pessoais —, muitas empresas hesitam em enviar dados externamente por questões de segurança.

Tecnologias de criptografia tradicionais (como AES e RSA) são excelentes em proteger dados armazenados em disco (Data at Rest) ou dados transmitidos pela rede (Data in Transit). No entanto, quando o servidor executa processamentos (cálculos) nos dados, como pesquisas ou aprendizado de máquina (Data in Use), é necessário descriptografar a cifra e retorná-la a texto plano primeiro. Se o servidor for hackeado exatamente no momento em que os dados estão descriptografados, ou se um administrador interno mal-intencionado visualizar os dados, isso levará diretamente a um vazamento de informações.

A tecnologia dos sonhos que supera essa fraqueza fundamental da “descriptografia durante o processamento” é a Criptografia Totalmente Homomórfica (Fully Homomorphic Encryption: FHE). Ao usar a FHE, torna-se possível realizar cálculos nos dados enquanto eles permanecem criptografados, sem qualquer descriptografia, e retornar apenas o texto cifrado do resultado para o cliente.

Neste artigo, explicaremos profundamente a FHE, o pilar da segurança da próxima geração, desde os seus conceitos até a história, o avanço revolucionário de Craig Gentry, a base matemática (como Ring-LWE), o maior desafio do “ruído” e sua solução (bootstrapping), chegando até as bibliotecas de implementação mais recentes.

1. O que é a Criptografia Homomórfica? Conceitos Básicos

“Homomorfismo” é um termo da álgebra que se refere à propriedade de mapeamento entre conjuntos que possuem uma determinada estrutura, preservando a estrutura de suas operações. A “propriedade homomórfica” na teoria da criptografia é a característica onde as operações no espaço de texto plano correspondem às operações no espaço de texto cifrado.

Expressado em uma fórmula simples, considere que a função de criptografia para os textos planos $m_1$ e $m_2$ seja $E(\cdot)$ e a função de descriptografia seja $D(\cdot)$. Sendo $\circ$ a operação sobre os textos planos (como adição ou multiplicação) e $\diamond$ a operação sobre os textos cifrados, a seguinte relação é mantida:

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

Em outras palavras, ao descriptografar o resultado da aplicação de alguma operação $\diamond$ nos textos cifrados $E(m_1)$ e $E(m_2)$, obteremos o mesmo resultado da operação $\circ$ feita nos textos planos originais.

Fluxo de Dados na Computação em Nuvem

A arquitetura de processamento em nuvem usando a FHE é completamente diferente da arquitetura tradicional. O diagrama a seguir ilustra o fluxo de processamento seguro de dados utilizando a FHE.

O servidor recebe os dados criptografados $E(x)$, mas como ele não possui a chave secreta, ele é absolutamente incapaz de saber o conteúdo dos dados. No entanto, explorando as propriedades da FHE, é possível aplicar a função $f$ (por exemplo, um modelo de inferência de aprendizado de máquina) ao texto cifrado e gerar $E(f(x))$. O cliente recebe isso e, descriptografando-o com sua própria chave secreta, obtém o resultado desejado $y = f(x)$.

2. A História da Evolução da Criptografia Homomórfica: PHE, SHE, FHE

A criptografia homomórfica não atingiu sua forma “totalmente” atual de uma só vez. Ela é amplamente classificada em três estágios dependendo dos tipos e da quantidade de operações que podem ser realizadas.

Partially Homomorphic Encryption (PHE: Criptografia Parcialmente Homomórfica)

A PHE é um método de criptografia que permite que apenas uma das operações (ou adição ou multiplicação) seja executada um número ilimitado de vezes. Na verdade, criptografias com essa propriedade existem há muito tempo.

Criptografia RSA (Homomorfismo para multiplicação) A criptografia RSA obteve inadvertidamente propriedade homomórfica multiplicativa. Dados os textos planos $m_1, m_2$ e a chave pública $(e, N)$: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ Ao multiplicá-los: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ Assim, a multiplicação dos textos cifrados corresponde à multiplicação dos textos planos.
Criptografia Paillier (Homomorfismo para adição) A criptografia Paillier, inventada em 1999, possui propriedade homomórfica para a adição. Tem sido implementada na prática em sistemas como o voto eletrônico (onde os votos criptografados são agregados e apenas o resultado final é descriptografado).

Somewhat Homomorphic Encryption (SHE: Criptografia Homomórfica Limitada)

Este método pode executar tanto a adição quanto a multiplicação, mas há um limite no número de vezes (a profundidade do circuito) em que as operações podem ser realizadas. Devido ao acúmulo de “ruído” discutido mais adiante, após realizar mais do que um certo número de multiplicações, a descriptografia se torna impossível. A criptografia BGN (Boneh-Goh-Nissim) de 2005 entra nessa categoria, mas tinha limites quando se tentava cálculos complexos práticos (como o deep learning).

Fully Homomorphic Encryption (FHE: Criptografia Totalmente Homomórfica)

Um esquema de criptografia no qual tanto a adição quanto a multiplicação podem ser realizadas um número ilimitado de vezes. Semelhante à completude de Turing na teoria da informação, se a adição (correspondente a XOR) e a multiplicação (correspondente a AND) puderem ser combinadas infinitamente, significa que, em princípio, qualquer função ou algoritmo computável pode ser executado enquanto os dados permanecem criptografados.

Por muito tempo, a FHE foi chamada de o “Santo Graal do mundo da criptografia” e muitos pensavam ser impossível. No entanto, em 2009, Craig Gentry, que estava em um programa de doutorado na Universidade de Stanford na época, propôs o primeiro esquema de FHE usando Reticulados Ideais (Ideal Lattices), chocando o mundo.

3. A Base Matemática da FHE: O Problema LWE e Ring-LWE

Muitos esquemas modernos de FHE baseiam-se no problema LWE (Learning With Errors), um difícil problema matemático da “Criptografia baseada em Reticulados (Lattice-based Cryptography)”, também conhecida como Criptografia Pós-Quântica (Post-Quantum Cryptography).

Entendimento Intuitivo do Problema LWE

Resolver um sistema de equações lineares é fácil usando métodos como a eliminação de Gauss.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

No entanto, o que acontece se adicionarmos um pequeno “erro aleatório (ruído)” $e$ ao resultado destas equações?

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

Ao apenas adicionar esse erro $e$, o problema de descobrir o vetor de variáveis secretas $\vec{s}$ se transforma em um problema NP-difícil, extremamente complicado de ser decifrado mesmo utilizando os supercomputadores ou computadores quânticos de hoje. Esse é o problema LWE.

Problema Ring-LWE (RLWE)

Como o problema LWE padrão envolve operações com matrizes, ele sofria da desvantagem de possuir tamanhos de chave extremamente grandes (às vezes chegando à escala de gigabytes) e de ter baixa eficiência computacional. O problema Ring-LWE (RLWE), que utiliza operações sobre um anel polinomial, foi introduzido para resolver esse problema.

No RLWE, os elementos pertencem a um anel polinomial $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ (onde $N$ é uma potência de 2, e $q$ é um número primo para o módulo). Se a chave secreta for o polinômio $s(x)$, um polinômio aleatório for $a(x)$, e um polinômio de ruído pequeno for $e(x)$, o par de chaves públicas será:

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

No momento da criptografia, a propriedade desse polinômio é usada para codificar o texto plano $m(x)$ e gerar o texto cifrado.

4. A Maior Barreira: “Ruído” e o Bootstrapping de Gentry

O conceito mais importante no entendimento da FHE é “a gestão do ruído”.

Em criptografias baseadas em LWE/RLWE, pequenos “ruídos (erros)” são intencionalmente incluídos para garantir a segurança. O processo de descriptografia do texto cifrado $c$ do texto plano $m$ pode ser expresso em termos gerais pela seguinte fórmula:

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

Durante a descriptografia, o texto plano $m$ correto é obtido pela remoção desse noise por meio de processos como o arredondamento. Contudo, ao realizar operações homomórficas (especialmente a multiplicação) nos textos cifrados, esse ruído se amplifica drasticamente.

Adição homomórfica: O ruído aumenta aditivamente ($e_1 + e_2$). É um aumento relativamente suave.
Expressão matemática da propriedade homomórfica com adição homomórfica: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
Multiplicação homomórfica: O ruído explode multiplicativamente (pois envolve fatores como $e_1 \times e_2$). Apenas multiplicando algumas vezes, o ruído pode exceder o limiar $q/2$, impossibilitando o arredondamento correto e levando à falha da descriptografia.
Expressão matemática da propriedade homomórfica com multiplicação homomórfica: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

É por isso que a FHE permaneceu sem ser concretizada por um longo tempo, restrita a SHE (limitada em número de operações).

A Magia do Bootstrapping

A contribuição genial de Craig Gentry foi a invenção da técnica de redução de ruído chamada “bootstrapping”. Essa foi uma mudança de paradigma na criptografia.

Intuitivamente, é o processo de “‘descriptografar’ o texto cifrado dentro do seu estado criptografado para limpá-lo, antes que ele se torne tão repleto de ruído que quebre, e então colocá-lo em um novo texto cifrado”.

Suponha que temos um texto cifrado $C_{noisy}$ com muito ruído.
O cliente fornece antecipadamente ao servidor sua chave secreta $sk$ “criptografada com a chave pública”, ou seja, $E_{pk}(sk)$ (isto é chamado de chave de bootstrapping).
O servidor executa homomorficamente o Circuito de Descriptografia (Decryption Circuit) sobre $C_{noisy}$.
Especificamente, ele realiza uma “descriptografia dentro do espaço criptografado” aplicando $E_{pk}(sk)$ em $E_{pk}(C_{noisy})$.
Como este circuito de descriptografia é em si mesmo uma operação homomórfica, ele gerará um novo ruído, mas o ruído do novo texto cifrado gerado, $C_{fresh}$, é redefinido para um “nível fixo” constante.

graph LR A["Texto cifrado com alto ruído C_noisy"] --> B["Circuito de descriptografia homomórfica (Eval_Dec)"] C["Chave secreta criptografada E(sk)"] --> B B --> D["Texto cifrado com baixo ruído C_fresh"] style B fill:#ffeeba,stroke:#ffc107

Ao executar este bootstrapping periodicamente no meio dos cálculos, tornou-se teoricamente possível calcular circuitos de profundidade infinita (atingindo a FHE). No entanto, no esquema inicial de Gentry, o custo computacional para esse processo de bootstrapping era desesperadamente alto, levando de dezenas de minutos a horas para ser executado uma única vez.

5. Gerações de FHE e a Evolução dos Principais Esquemas

Para tornar a FHE viável na prática, criptógrafos de todo o mundo vêm competindo para aprimorar os algoritmos. Atualmente, a FHE é amplamente categorizada em quatro gerações ou famílias.

Segunda Geração: Aritmética Exata de Inteiros (BGV, BFV)

Surgidos entre 2011 e 2012, os esquemas BGV (Brakerski-Gentry-Vaikuntanathan) e BFV (Brakerski/Fan-Vercauteren). Baseados no RLWE, eles são apropriados para a aritmética modular com números inteiros (cálculos exatos). Eles têm como característica o suporte a técnicas de loteamento (Batching) como SIMD (Single Instruction, Multiple Data), que permite acomodar milhares de slots de dados em um único texto cifrado de polinômio gigante, possibilitando cálculos paralelos de uma só vez.

Terceira Geração: Aceleração do Bootstrapping (GSW, FHEW, TFHE)

O esquema GSW (Gentry-Sahai-Waters) de 2013 simplificou a estrutura da FHE. Isso então evoluiu para o TFHE (Fast Fully Homomorphic Encryption over the Torus), que é um dos métodos predominantes hoje em dia. A característica do TFHE é que o seu bootstrapping é extremamente rápido (na ordem de milissegundos). Ele é robusto no processamento ao nível de portas (circuitos lógicos como AND, XOR) e possui um tamanho de texto cifrado relativamente pequeno, tornando-o ideal para avaliar rapidamente circuitos lógicos arbitrários.

Quarta Geração: Especialização para Cálculo Aproximado e Aprendizado de Máquina (CKKS)

O esquema CKKS (Cheon-Kim-Kim-Song), proposto por Cheon et al. em 2017, pode ser considerado a tecnologia definitiva na proteção da privacidade para a IA e aprendizado de máquina modernos. Enquanto as versões anteriores da FHE focavam em “cálculos com números inteiros exatos”, o CKKS suporta homomorficamente “cálculos aproximados com números de ponto flutuante”. Ele demonstra um desempenho avassalador em cálculos com números reais onde pequenas margens de erro são toleradas, como no treinamento e inferência de redes neurais.

A tabela abaixo resume como escolher os esquemas conforme a finalidade:

Nome do Esquema	Tipo de Dados Adequado	Casos de Uso Recomendados	Características
BFV / BGV	Inteiros (Integer)	Cálculos estatísticos exatos, agregação de dados financeiros, buscas em DB	Alto rendimento via loteamento SIMD
CKKS	Números Reais (Real/Complex)	Aprendizado de Máquina (DNN, regressão logística), processamento de sinais	Aceleração via cálculo aproximado, reescalonamento
TFHE	Valores Booleanos (Boolean)	Circuitos lógicos arbitrários, buscas por strings, avaliação de funções não lineares	Bootstrapping super-rápido (escala de milissegundos)

6. Prática: Bibliotecas de FHE e Código Conceitual

Atualmente, existem inúmeras bibliotecas de código aberto que permitem usar a FHE sem necessitar de conhecimento profundo em criptografia.

Microsoft SEAL (Simple Encrypted Arithmetic Library): Biblioteca em C++ com suporte para os esquemas BFV, BGV e CKKS. É um dos padrões da indústria. O TenSEAL, seu wrapper em Python, é popular entre engenheiros de IA.
Zama (Concrete): Framework baseado em TFHE. Pode ser codificado em Rust/Python e oferece recursos (Concrete ML) para compilar modelos PyTorch existentes para executá-los em FHE.
OpenFHE: O sucessor do PALISADE, é uma biblioteca C++ abrangente que suporta todos os esquemas principais.

Exemplo de Programação FHE usando Python (TenSEAL)

Abaixo, mostramos um exemplo conceitual em Python usando o esquema CKKS, em que vetores de números reais são somados e multiplicados enquanto permanecem criptografados.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. Configuração do contexto (incluindo a geração das chaves)
# Usando o esquema CKKS e configurando o grau do polinômio para 8192
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # Fator de escala para números reais

# 2. Lado do cliente: Criptografia dos dados
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# Convertendo o vetor em texto plano para um texto cifrado (Originalmente executado no cliente)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. Lado do servidor: Operações no estado criptografado (Proteção do Data in Use)
# O servidor não conhece os textos planos, mas consegue realizar a adição e a multiplicação
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. Lado do cliente: Descriptografia do resultado
# Apenas o cliente que possui a chave secreta consegue ver o resultado
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"Resultado da adição descriptografado: {res_add}")
# Exemplo de saída: [3.5000001, 5.5000001, 7.5000002] (Uma pequena margem de erro por causa dos cálculos aproximados)

print(f"Resultado da multiplicação descriptografado: {res_mul}")
# Exemplo de saída: [3.0000002, 7.5000005, 14.0000003]

Como pode ser visto no código acima, operações normais de operadores de Python como enc_v1 + enc_v2 podem ser sobrecarregadas para expressar cálculos entre textos cifrados de maneira intuitiva. No lado do servidor, as operações vetoriais são completadas sem que se conheça o conteúdo do vetor.

7. Desafios da FHE: Desempenho e Aceleração por Hardware

Embora a FHE forneça uma segurança teoricamente perfeita, o maior desafio na sua aplicação prática é a “sobrecarga (overhead) de desempenho”.

Sobrecarga computacional: Comparado ao cálculo em texto plano, o cálculo sobre um texto cifrado na CPU é milhares a dezenas de milhares de vezes mais lento. Multiplicar polinômios e realizar bootstrapping exige cálculos computacionais imensos, como FFT (Transformada Rápida de Fourier) e NTT (Transformada da Teoria dos Números).
Expansão de Dados (Ciphertext Expansion): Um texto plano de alguns bytes, quando criptografado, pode aumentar de tamanho para alguns megabytes. Isso exerce forte pressão sobre a largura de banda de memória e da rede.

Abordagens de Resolução Através de Hardware

Para superar essa sobrecarga, esforços estão em andamento em todo o mundo para desenvolver aceleradores de hardware dedicados à FHE (suporte a ASIC, FPGA e GPU).

Aceleração com GPU: Esforços para usar as potentes GPUs (como as da NVIDIA) a fim de paralelizar os cálculos de NTT ou o bootstrapping estão progredindo e relatam velocidades que são dezenas de vezes mais rápidas em comparação com as implementações baseadas em software (ex.: 100x.ai, o backend CUDA TFHE-rs da Zama).
Projeto DARPA DPRIVE: A Defense Advanced Research Projects Agency (DARPA) dos EUA, está conduzindo o “DPRIVE (Data Protection in Virtual Environments)”, um projeto focado no desenvolvimento de hardware exclusivo projetado para elevar a velocidade do cálculo da FHE a uma capacidade equivalente à velocidade de execução em texto plano (com overhead dentro de 10x), que conta com parceiros como Intel, Microsoft, Intellectual Ventures e afins.
O Surgimento da FPU (FHE Processing Unit): Startups como Cornami e Optalysys têm se empenhado em construir chips dedicados à FHE usando arquiteturas de silício especiais ou tecnologias de computação óptica.

Num futuro próximo, poderemos presenciar a era em que as FPUs estejam incluídas como padrão em infraestruturas de servidores ou na nuvem, da mesma forma que as NPUs (Neural Processing Units) ocorrem na IA.

8. Casos de Uso Esperados

Hoje em dia, onde a FHE está alcançando uma velocidade em níveis práticos, são aguardadas inovações disruptivas nos seguintes campos:

Proteção à privacidade em análises genômicas e médicas: Informações biológicas (dados de DNA) ou laudos e exames provindos de muitos hospitais diferentes poderão receber modelos de IA em conjunto pelas nuvens sob formatação FHE de estado permanente cifrado, o qual atende inteiramente os limites impostos pelas leis legislativas de conformidade (como a LGPD, HIPAA e GDPR). Esses esforços proporcionarão construções avançadas com diagnóstico e produção em tratamentos farmacêuticos precisos sobre patologias de tumores cancerosos e desenvolvimento de novas medicações sem riscos.
Verificação antifraude nas Instituições Financeiras e PLD (Prevenção à Lavagem de Dinheiro): Instituições financeiras em concorrência poderão verificar em mútuo auxílio o quadro dos extratos ou as referências transacionais de cada cliente sob encriptação, contendo integridade não visível para apontar enormes cadeias criminosas de fraude que praticam remessas desonestas entre bancos nas transferências. O que possibilita executar a chamada avaliação multi-bancos.
APIs de IA Seguras de Inferências Pessoais (MaaS: Model as a Service): Usuários usarão chaves particulares próprias (mensagens digitadas de comandos/prompt, rostos, fotos, imagens de íris, gravações da sua fala) e repassarão elas de maneira cifrada e inacessível a uma determinada aplicação de Inteligência Artificial para Inferência de Modelos de Linguagem (a exemplo de um modelo LLM igual o ChatGPT ou congêneres da tecnologia de processamento natural humano). O Fornecedor provedor detentor da IA despacha e fabrica formulações conclusivas não sabendo jamais qual era o dado ali originário de partida; remetendo sua solução redigida na total cifra. Desse modo erradica o abalo de “permitir o espião no treinamento indevido sob rastros dos detalhes expostos pelo indivíduo na internet privada e sensível”.

9. Conclusão: O Futuro da Criptografia em Direção ao “Cálculo Invisível”

Assim como a invenção da criptografia de chave pública (como a RSA) na década de 1970 possibilitou a comunicação segura pela internet (como no HTTPS), a invenção da FHE por Craig Gentry é um dos marcos mais cruciais em toda a história criptográfica da humanidade.

No presente, a Criptografia Totalmente Homomórfica (FHE) deu um salto dos laboratórios teóricos para o mundo real, entrando agora na etapa pela qual as corporações da Microsoft, IBM, Intel, Google, assim como uma quantidade de startups lutam firmemente em direção ao estado da comercialização tangível no sistema prático. O problema da quantidade do peso do tamanho expansível nos dados codificados ainda está contido no rol de entraves e desafios a transpor, mas à luz do requinte arquitetônico dos modelos e softwares matemáticos de algoritmo em sincronia contínua de aperfeiçoamento nos hardwares superacelerados tecnológicos, sua capacidade de melhoria atinge avanços velozes cujas expectativas superam a Lei de Moore.

Daqui a poucos anos, a frase “processar e calcular enquanto os dados se encontram em criptografia resguardada” será desprovida da sensação da complexidade esotérica especial e rara e deve vir a ser consolidada na prática essencialmente como base obrigatória generalizada do mercado na segurança protetora das soluções da arquitetura pela nuvem de serviços mundiais atuais. Afinal, no palco dessa presente comunidade conectada (data-driven) embasada globalmente via bases contínuas digitais, a FHE (Criptografia Totalmente Homomórfica) assume sua titularidade do suporte principal absoluto para a segurança nas próximas fronteiras do amanhã que concretiza a conciliação unânime final das realidades — da máxima e rigorosa preservação do resguardo íntimo da privacidade e paralelamente de suas inúmeras flexibilidades promissoras no uso interconectado nos dados.

Fundamentos Matemáticos da Criptografia de Curva Elíptica (ECC) e sua Implementação em C++

Fri, 11 Sep 2026 10:00:00 +0900

Fundamentos Matemáticos da Criptografia de Curva Elíptica (ECC) e sua Implementação em C++

Na tecnologia criptográfica moderna, a Criptografia de Curva Elíptica (Elliptic Curve Cryptography: ECC) desempenha um papel extremamente importante. Desde nossas comunicações diárias na internet (HTTPS/TLS), até o enclave seguro dos smartphones, autenticação de servidores via SSH, autenticação sem senha como FIDO e, além disso, criptoativos como Bitcoin e Ethereum, não é exagero dizer que a base de confiança da sociedade digital moderna é sustentada pela ECC.

Neste artigo, explicaremos de forma exaustiva e com um volume impressionante como essa criptografia de curva elíptica funciona, partindo da teoria matemática bela e complexa por trás dela (geometria algébrica em corpos finitos), passando pelo método de implementação real usando C++, até as técnicas de codificação segura para evitar ataques de canal lateral (ataques de tempo).

1. Por que a Criptografia de Curva Elíptica? (Comparação com RSA)

Por muito tempo, o sinônimo de criptografia de chave pública foi a Criptografia RSA. A criptografia RSA baseia a sua segurança na “dificuldade de fatoração de números compostos gigantes”. No entanto, com o aumento da capacidade de cálculo dos computadores, surgiu a necessidade de aumentar continuamente o tamanho da chave RSA (o número de bits do módulo) para manter a segurança. Atualmente, recomenda-se um tamanho de chave de no mínimo 2048 bits, ou 3072 bits e 4096 bits para maior segurança.

Por outro lado, a criptografia de curva elíptica (ECC) baseia a sua segurança em outra dificuldade matemática chamada “Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP)”. Até o momento, nenhum algoritmo eficiente (como algoritmos de tempo subexponencial) foi descoberto para resolver o ECDLP, e mesmo os métodos de ataque mais eficientes conhecidos requerem tempo exponencial.

Devido a essa propriedade, a ECC possui a vantagem decisiva de alcançar uma força de segurança equivalente à do RSA com um tamanho de chave muito menor.

Força de Segurança (bits)	Tamanho da Chave RSA (bits)	Tamanho da Chave de Curva Elíptica (bits)	Proporção do Tamanho da Chave
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Como a tabela acima mostra, para obter uma força de segurança de 128 bits (o padrão atual), o RSA requer uma chave de 3072 bits, mas a ECC requer apenas 256 bits. Isso permite a redução da quantidade de cálculos, a diminuição do uso de memória e a economia de largura de banda de rede, apresentando uma vantagem esmagadora, especialmente em ambientes com recursos limitados como dispositivos IoT e cartões inteligentes.

2. Preparação Matemática: Teoria dos Grupos e Corpos Finitos

Para entender verdadeiramente a criptografia de curva elíptica, é necessário compreender os conceitos básicos de álgebra abstrata (teoria dos grupos e teoria dos corpos). Aqui, resumiremos os conhecimentos prévios para construir a ECC.

2.1. Grupos (Group) e Grupos Abelianos

Um Grupo (Group) é um conjunto de um dado conjunto $G$ com uma operação binária nesse conjunto (aqui será a adição $+$), $(G, +)$, que satisfaz os 4 axiomas a seguir.

Fechamento (Closure): Para quaisquer $a, b \in G$, $a + b \in G$.
Associatividade (Associativity): Para quaisquer $a, b, c \in G$, $(a + b) + c = a + (b + c)$ é válido.
Existência do Elemento Neutro (Identity element): Existe um elemento $e \in G$ tal que para qualquer $a \in G$, $a + e = e + a = a$. No caso de grupos aditivos, este elemento neutro é normalmente denotado como $0$ ou $\mathcal{O}$.
Existência do Elemento Inverso (Inverse element): Para qualquer $a \in G$, existe um elemento $b \in G$ tal que $a + b = b + a = e$. Esse $b$ é denotado como $-a$.

Além disso, um grupo que não altera o resultado mesmo mudando a ordem da operação, ou seja, que satisfaz a seguinte condição, é chamado de Grupo Abeliano (Grupo Comutativo).

Comutatividade (Commutativity): Para quaisquer $a, b \in G$, $a + b = b + a$ é válido.

O conjunto de pontos em uma curva elíptica forma este grupo abeliano pela definição de uma regra de adição específica.

2.2. Corpos Finitos (Finite Field)

Na teoria criptográfica, em vez de corpos contínuos com infinitos elementos como os números reais ou complexos, usamos Corpos Finitos (Finite Field) ou Corpos de Galois, onde o número de elementos é finito.

O corpo finito mais básico é o corpo primo $\mathbb{F}_p$ que usa o número primo $p$. Ele é a definição das quatro operações aritméticas (adição, subtração, multiplicação e divisão) em módulo $p$ (resto da divisão por $p$) no conjunto de inteiros $\{0, 1, 2, \dots, p-1\}$.

Adição: $(a + b) \pmod p$
Subtração: $(a - b) \pmod p$
Multiplicação: $(a \times b) \pmod p$
Divisão: $a \times b^{-1} \pmod p$ (onde $b^{-1}$ é o inverso multiplicativo de $b$ módulo $p$)

O cálculo do Inverso Multiplicativo Modular (Modular Multiplicative Inverse) é extremamente importante nas implementações criptográficas. Para encontrar o $b^{-1}$ que satisfaz $b \times b^{-1} \equiv 1 \pmod p$, são utilizados principalmente os 2 algoritmos a seguir.

Algoritmo de Euclides Estendido (Extended Euclidean Algorithm): Rápido, mas dependendo da implementação, o tempo de processamento depende do valor de entrada, o que representa um risco de ataques de tempo.
Pequeno Teorema de Fermat (Fermat’s Little Theorem): Quando $p$ é um número primo e $b \neq 0$, $b^{p-1} \equiv 1 \pmod p$ é válido. Dividindo ambos os lados por $b$, obtemos $b^{p-2} \equiv b^{-1} \pmod p$. Em outras palavras, o inverso é encontrado calculando $b$ elevado a $p-2$. A operação de exponenciação é fácil de implementar em tempo constante, por isso é a preferida em implementações criptográficas.

3. Equação da Curva Elíptica e Geometria

3.1. Forma Normal de Weierstrass

Uma Curva Elíptica (Elliptic Curve) é geralmente uma curva plana definida pela equação chamada de Forma normal de Weierstrass (Weierstrass normal form) a seguir.

$$ y^2 = x^3 + ax + b $$

Aqui, $a$ e $b$ são constantes, e como condição para que a curva não possua singularidades (autointerseção ou cúspides) (para que seja uma curva suave), exige-se que o Discriminante (Discriminant) $\Delta$ a seguir não seja zero.

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

Como as curvas com singularidades comprometem a segurança criptográfica, coeficientes $a, b$ que satisfaçam essa condição são sempre escolhidos.

3.2. Ponto no Infinito (Point at Infinity)

Para transformar a curva elíptica em um grupo matematicamente perfeito, além dos pontos no plano, introduzimos um ponto virtual chamado “Ponto no Infinito (Point at Infinity)”. Ele é denotado como $\mathcal{O}$ (O).

O ponto no infinito $\mathcal{O}$ é definido como o ponto onde todas as linhas verticais se cruzam no infinito. Na teoria dos grupos, este ponto no infinito $\mathcal{O}$ funciona como o elemento neutro na adição (zero).

Ou seja, para qualquer ponto $P$ na curva, vale o seguinte:

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

Além disso, o inverso $-P$ do ponto $P = (x, y)$ é definido como o ponto simétrico em relação ao eixo x $(x, -y)$. Portanto:

$$ P + (-P) = \mathcal{O} $$

é obtido.

4. Operações de Grupo em Curvas Elípticas (Adição de Pontos e Dobro)

O núcleo da criptografia de curva elíptica é a operação de “Adição (Addition)” entre pontos na curva. Diferente da adição normal de inteiros, ela é baseada em operações geométricas.

4.1. Adição Geométrica (Tangent and Chord Method)

O procedimento para somar 2 pontos diferentes $P$ e $Q$ na curva para encontrar um novo ponto $R$ ($R = P + Q$) é o seguinte.

Trace uma reta (corda) passando pelo ponto $P$ e pelo ponto $Q$.
Esta reta sempre cruzará a curva elíptica em um terceiro ponto (vamos chamá-lo de $-R$). (*Pelo teorema da geometria algébrica)
O ponto simétrico de $-R$ em relação ao eixo x (o ponto com o sinal da coordenada y invertido) será o ponto $R$ desejado.

graph TD Step1["Traçar uma reta ligando P(x1, y1) e Q(x2, y2)"] --> Step2["Encontrar o terceiro ponto de interseção -R com a curva"] Step2 --> Step3["Refletir -R no eixo x para obter R(x3, y3)"] Step3 -.-> Result["Este é R = P + Q"]

4.2. Dobro de um Ponto (Point Doubling)

Quando somamos o ponto $P$ ao próprio ponto $P$ ($P + P = 2P$), não podemos traçar uma reta que passe por 2 pontos. Neste caso, traçamos a tangente (Tangent) à curva no ponto $P$.

Trace a tangente à curva no ponto $P$.
Esta tangente cruzará a curva em outro ponto $-R$.
O ponto simétrico desse cruzamento em relação ao eixo x será o ponto $R = 2P$ desejado.

4.3. Fórmulas de Cálculo Algébrico

As operações geométricas são convertidas em fórmulas algébricas para que possam ser calculadas por computadores. As operações são todas feitas no corpo finito $\mathbb{F}_p$ (módulo $p$).

Sejam os pontos $P = (x_1, y_1)$ e $Q = (x_2, y_2)$. Além disso, seja o ponto do resultado do cálculo $R = P + Q = (x_3, y_3)$.

Seja $\lambda$ (lambda) a inclinação da reta.

[Caso 1: Quando $P \neq Q$ (Adição de Pontos)] A inclinação $\lambda$ é a taxa de variação entre os 2 pontos.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

Usando esse $\lambda$, $x_3, y_3$ são calculados da seguinte forma.

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[Caso 2: Quando $P = Q$ (Dobro de Ponto)] A inclinação $\lambda$ será a inclinação da tangente, encontrada pela derivada. (Diferenciação implícita de $y^2 = x^3 + ax + b$)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

Portanto,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

As equações de $x_3, y_3$ têm o mesmo formato da adição, mas como $x_2 = x_1$, ficam assim:

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] Estas fórmulas contêm divisões (cálculo do inverso modular) como $(x_2 - x_1)^{-1}$ e $(2y_1)^{-1}$. O cálculo do inverso modular tem um custo computacional muito alto, então em implementações reais, geralmente se usa um sistema de coordenadas projetivas, como o “Sistema de Coordenadas Jacobiano (Jacobian Coordinates)”, que adia a divisão.

5. Multiplicação Escalar e o Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP)

Na criptografia de curva elíptica, a operação de maior complexidade computacional e que forma o núcleo da segurança é a Multiplicação Escalar (Scalar Multiplication).

5.1. O que é a Multiplicação Escalar

A operação de somar um ponto $P$ a ele mesmo $k$ vezes é chamada de multiplicação escalar e denotada como $kP$.

$$ kP = \underbrace{P + P + \dots + P}_{k\text{ vezes}} $$

Aqui, $k$ é um inteiro muito grande (por exemplo, um número inteiro de 256 bits).

5.2. Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP)

A segurança da criptografia de curva elíptica depende da dificuldade do seguinte problema.

Problema do Logaritmo Discreto em Curvas Elípticas (Elliptic Curve Discrete Logarithm Problem: ECDLP) Dado um ponto conhecido $P$ (ponto base) e um ponto de resultado do cálculo $Q$, encontre o escalar $k$ que satisfaz $Q = kP$.

É fácil (em tempo polinomial) calcular $Q$ a partir de $k$ e $P$ (direção direta) usando os algoritmos que serão mencionados depois, mas calcular inversamente $k$ a partir de $P$ e $Q$ (direção inversa) é virtualmente impossível sem usar uma busca exaustiva (força bruta), tornando-a uma função de via única. Nos protocolos criptográficos, $k$ corresponde à “chave privada” e $Q$ corresponde à “chave pública”.

5.3. Algoritmo Double-and-Add

Quando $k$ é um número gigante (ex: $2^{256}$), a adição direta de $P$ por $k$ vezes não terminaria nem com o fim da vida do universo. Assim, para realizar a multiplicação escalar rapidamente, usa-se o método Double-and-Add (Método Binário).

Esta é a versão em curva elíptica da “exponenciação modular rápida” para calcular rapidamente potências de números inteiros. Ele expressa o escalar $k$ em binário e o processa a partir do bit mais significativo.

Inicialize o ponto $R$, que guardará o resultado, como $\mathcal{O}$.
Repita do bit mais significativo até o bit menos significativo de $k$:
- Dobre $R$ (Point Doubling: $R = 2R$)
- Se o bit atual for 1, adicione $P$ a $R$ (Point Addition: $R = R + P$)

Com este algoritmo, a complexidade computacional é drasticamente reduzida de $O(k)$ para $O(\log_2 k)$, tornando o cálculo possível em tempo realista (na ordem de milissegundos).

6. Troca de Chaves Diffie-Hellman em Curva Elíptica (ECDH)

Aqui explicaremos o funcionamento do protocolo mais representativo de aplicação da ECC, o protocolo de troca de chaves ECDH (Elliptic Curve Diffie-Hellman). O ECDH é um mecanismo que permite que Alice e Bob gerem e compartilhem de forma segura uma chave secreta comum (chave de sessão) sobre um canal de comunicação sujeito a interceptação (é o núcleo do handshake TLS).

[Parâmetros Prévios (Parâmetros de Domínio)] As duas partes compartilham com antecedência a curva elíptica $E$ a ser usada, um número primo $p$, e um ponto base $G$. (Exemplos incluem NIST P-256 e secp256k1)

sequenceDiagram participant Alice as "Alice" participant Bob as "Bob" Note over Alice,Bob: "Parâmetros Públicos: Curva E, Ponto base G, Primo p" Alice->>Alice: "Gerar chave privada d_A (inteiro aleatório)" Alice->>Alice: "Calcular chave pública Q_A = d_A * G" Bob->>Bob: "Gerar chave privada d_B (inteiro aleatório)" Bob->>Bob: "Calcular chave pública Q_B = d_B * G" Alice->>Bob: "Enviar chave pública Q_A (texto claro)" Bob->>Alice: "Enviar chave pública Q_B (texto claro)" Alice->>Alice: "Calcular segredo compartilhado S = d_A * Q_B" Bob->>Bob: "Calcular segredo compartilhado S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "O resultado do cálculo S de ambos é perfeitamente idêntico!"

Um interceptador (Eve) pode capturar $G$, $Q_A$ e $Q_B$ que fluem na via de comunicação, mas devido à dificuldade do ECDLP, não pode deduzir a chave privada $d_A$ de Alice a partir de $Q_A = d_A \cdot G$. Além disso, multiplicar $Q_A$ e $Q_B$ não resulta na chave compartilhada $S$, de forma que o interceptador não pode calcular $S$.

7. Armadilhas de Implementação: Ataques de Canal Lateral e Contramedidas

Mesmo que seja um algoritmo de criptografia teoricamente perfeito, vulnerabilidades podem surgir no processo de implementá-lo como um programa. Isso é conhecido como “Ataque de Canal Lateral (Side-Channel Attack)”.

7.1. Ataques de Tempo (Timing Attack)

Vamos rever o algoritmo Double-and-Add mencionado anteriormente.

1
2
3
4
5
6
7
8


// Pseudocódigo vulnerável de Double-and-Add
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Sempre executado
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // Executado apenas quando o bit é 1!
 }
}

Esta implementação tem uma falha fatal. Como a Adição de Pontos (Point Addition) é executada quando o bit é 1, o tempo de cálculo é ligeiramente maior do que quando o bit é 0. Além disso, o comportamento da previsão de ramificação do processador e da memória cache também muda. Observando estatisticamente essas diferenças microscópicas no tempo de computação (ou consumo de energia) milhares de vezes, um atacante pode restaurar a sequência de bits da chave secreta $k$ completamente, bit a bit. Esse é o ataque de tempo.

7.2. Implementação em Tempo Constante (Constant-Time): Montgomery Ladder

Para prevenir ataques de tempo, é necessário adotar um algoritmo em que a sequência de instruções executadas e o tempo de computação sejam sempre constantes (Constant-Time), independentemente do valor do bit da chave secreta.

Um exemplo representativo disso é a Escada de Montgomery (Montgomery Ladder).

graph TD Start["Inicialização: R0 = O, R1 = P"] --> LoopStart["Para cada bit i (a partir do mais significativo)"] LoopStart --> Cond{"Qual é o valor de k_i?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["Ir para o próximo bit"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Todos os bits concluídos"| End["Término: R0 é o resultado (kP)"]

A beleza da Montgomery Ladder é que, seja o bit 0 ou 1, “sempre 1 Point Addition e 1 Point Doubling” são executados. Isto elimina completamente a dependência de dados no tempo de computação.

No entanto, se a própria ramificação (if (k_i == 0)) existir, haverá um risco de variação no tempo de execução devido à otimização do compilador e à previsão de ramificação da CPU. Portanto, nas implementações em Tempo Constante reais, as ramificações condicionais (comandos if) são eliminadas e usa-se a troca condicional (Conditional Swap) usando operações de bit.

8. Implementação da Criptografia de Curva Elíptica em C++

A partir daqui, transformaremos a teoria em código C++. Bibliotecas de criptografia práticas (como OpenSSL e libsodium) usam otimizações avançadas em Assembly e o sistema de coordenadas jacobiano, mas aqui mostraremos a estrutura de uma implementação de tempo constante simples usando coordenadas afins, para aprofundar a compreensão matemática.

Supõe-se que será usado boost::multiprecision::cpp_int para operações com números inteiros enormes.

8.1. Aritmética Modular e Inverso

Primeiro, vamos definir as funções auxiliares de cálculo sobre o corpo finito. Vamos implementar o cálculo do inverso com base no pequeno teorema de Fermat.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// Exemplo: primo p e parâmetros da secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Aritmética modular retornando resto positivo
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// Cálculo de exponenciação modular (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// Inverso modular usando o Pequeno Teorema de Fermat
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Pressupondo que m seja primo: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Representação dos Pontos e Operações de Grupo (Adição e Dobro)

Vamos implementar a estrutura Point para gerenciar o ponto no infinito por meio de uma flag e a fórmula de adição.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // Geração do ponto no infinito
 Point() : x(0), y(0), isInfinity(true) {}

 // Geração de um ponto normal
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Adição de pontos em uma curva elíptica (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = ponto no infinito
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (Quando P = Q)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (Quando P != Q)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Implementação da Troca Condicional em Tempo Constante (Constant-Time Conditional Swap)

Ao trocar o conteúdo de variáveis com base no valor do bit da chave privada, efetuamos a troca apenas com operações de bit (máscaras) sem usar o comando if. Deste modo, o caminho de execução se torna estritamente constante.

[!TIP] Em implementações reais, classes de números inteiros de múltipla precisão dinamicamente alocadas, como cpp_int, não são adequadas para processamento em Tempo Constante (Constant-Time). Isso ocorre porque informações de temporização vazam por causa de alocações de memória e mudanças de tamanho de vetor. Em bibliotecas de produção, representamos números inteiros de tamanho fixo (por exemplo, arrays de 4 elementos uint64_t) e implementamos processamento de máscara a nível de bit. A seguir, está um exemplo conceitual.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Constant-Time Swap Conceitual (assumindo números inteiros de tamanho fixo)
// Se bit for 1, troca P1 e P2; se for 0, não troca
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit é 0 ou 1. A máscara é todos os bits 1 (0xFF..) se bit=1 e todos 0 se for 0.
 // (Aqui, para explicação, assumimos cada palavra da classe BigInt de tamanho fixo como w)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // As coordenadas y e as flags isInfinity também são processadas da mesma forma
 }
 */

 // ※ É difícil realizar uma troca de tempo constante perfeita usando boost::multiprecision,
 // então, aqui nos limitaremos a simular a ramificação para entender a lógica.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Multiplicação Escalar pela Escada de Montgomery (Montgomery Ladder)

Combinando os comandos pointAdd e cswap acima mencionados, implementaremos uma multiplicação escalar segura.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Multiplicação escalar k * P (método Montgomery Ladder)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Ponto no infinito
 Point R1 = P;

 // Obtém o comprimento em bits de k (256 bits se secp256k1)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Obtém o valor do bit i (0 ou 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Se bit == 1, faz swap entre R0 e R1
 cswap(R0, R1, bit);

 // Executa sempre a mesma operação (Point Addition e Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Se bit == 1, faz o swap novamente para retornar ao estado original
 cswap(R0, R1, bit);
 }

 return R0;
}

Por essa lógica de implementação, se cada bit do escalar $k$ é 0 ou 1, as operações executadas em cada iteração de loop (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) seguem exatamente o mesmo fluxo, e é possível prevenir vigorosamente o vazamento de informações secretas através das diferenças de temporização ou padrões de acesso ao cache.

9. Conclusão

À primeira vista, a criptografia de curva elíptica (ECC) pode parecer estranha: “Por que uma operação geométrica de traçar retas e dobrar interseções resulta em criptografia?”. No entanto, é o produto da fusão milagrosa da matemática e da criptografia que permite que uma brilhante função de via única (o problema do logaritmo discreto) seja estruturada por meio do mapeamento do mundo discreto dos corpos finitos.

Este artigo abordou os seguintes pontos cruciais.

Superioridade em relação ao RSA: Fornece segurança poderosa com comprimentos de chave muito curtos, sendo a mais adequada para as eras móveis e IoT contemporâneas.
Bases da Teoria dos Grupos e Corpos Finitos: As estruturas matemáticas subjacentes da ECC.
Fórmulas de Adição e Dobro: O método para implementar operações algébricas de grupo usando equações de Weierstrass.
Ameaça de Ataques de Canal Lateral: As ramificações condicionais dependentes de bit da chave privada causam vulnerabilidades fatais.
Implementação de Tempo Constante (Constant-Time): Técnicas de codificação em C++ para evitar ataques através de comportamentos unificados de nível de hardware usando Escada de Montgomery (Montgomery Ladder) e Troca Condicional (Conditional Swap).

Não é recomendado (“Don’t roll your own crypto”) criar suas próprias bibliotecas criptográficas que operem efetivamente no ambiente de produção, uma vez que o risco de segurança é extremamente alto. No entanto, compreender a fundo o seu algoritmo interno e o contexto matemático que operem lá dentro deveria ser uma arma indubitavelmente forte para qualquer engenheiro que queira criar e operar um sistema ainda mais seguro e com maior desempenho.

No próximo artigo, aprofundaremos um pouco mais sobre o mecanismo do ECDSA (Elliptic Curve Digital Signature Algorithm), um algoritmo de assinatura digital que usa essas curvas elípticas, bem como a Assinatura de Schnorr usada no Bitcoin.

Existe algum algoritmo além do GNFS (Crivo Geral dos Campos de Números)?

Fri, 11 Sep 2026 09:00:00 +0900

1. Introdução: A Fatoração de Inteiros e a Base da Criptografia Moderna

A segurança das comunicações na Internet na sociedade moderna depende fortemente da segurança da criptografia de chave pública RSA. A segurança do RSA baseia-se na suposição matemática da “dificuldade de fatorar números compostos gigantes”. Se um algoritmo de fatoração extremamente eficiente for descoberto, a infraestrutura de comunicação em todo o mundo desmoronaria desde a sua base.

Atualmente, o Crivo Geral dos Campos de Números (GNFS - General Number Field Sieve) reina como o algoritmo mais rápido e poderoso para a fatoração de números inteiros gigantes utilizando computadores clássicos. O GNFS nasceu como uma extensão do Crivo Especial dos Campos de Números (SNFS), proposto no final da década de 1980, e estabeleceu recordes de fatoração para números compostos enormes como o RSA-768 e RSA-250 até os dias de hoje.

No entanto, criptógrafos e matemáticos sempre se fazem as seguintes perguntas: “Existe algum algoritmo clássico que supere o GNFS?” “Onde está o limite dos computadores clássicos?” e “Como os computadores quânticos irão contornar essa situação?”

Neste artigo, dissecaremos exaustivamente as profundas estruturas matemáticas por trás do GNFS e conduziremos uma análise técnica detalhada da seleção de polinômios, processo de crivagem e etapas de álgebra linear usando o método de Block Wiedemann. Além disso, consideraremos métodos de extensão para GNFS, como as melhorias de Coppersmith, e compararemos e explicaremos as diferenças cruciais entre os algoritmos clássicos de tempo subexponencial (Sub-exponential time) e os algoritmos quânticos de tempo polinomial a partir de uma perspectiva matemática.

2. Complexidade Assintótica e Notação L (L-notation)

Ao avaliar a complexidade de algoritmos de fatoração, a Notação L (L-notation) é usada para expressar o tempo subexponencial relativo ao número de dígitos da entrada $n$, ao invés da notação padrão de tempo polinomial (como $O(n^k)$). A notação L é definida da seguinte forma:

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

Aqui, $n$ é o número inteiro a ser fatorado e $\ln n$ é o logaritmo natural, o qual é proporcional ao comprimento em bits de $n$.

Quando $\alpha = 0$: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$, representando um tempo polinomial (Polynomial time) em relação ao comprimento em bits.
Quando $\alpha = 1$: $L_n[1, c] = \exp(c \ln n) = n^c$, representando um tempo exponencial (Exponential time) em relação ao comprimento em bits.
Quando $0 < \alpha < 1$: Representa um tempo subexponencial (Sub-exponential time) localizado entre o tempo polinomial e o tempo exponencial.

A evolução dos algoritmos de fatoração no passado tem sido a história de reduzir gradualmente o valor desse $\alpha$.

Fração Contínua (CFRAC) e Crivo Quadrático de Múltiplos Polinômios (MPQS): Pertencem à classe $\alpha = 1/2$ e a complexidade de cálculo é de cerca de $L_n[1/2, 1]$.
Crivo Geral dos Campos de Números (GNFS): Alcançou $\alpha = 1/3$ e ostenta a complexidade computacional mais rápida de $L_n[1/3, (64/9)^{1/3}]$ entre os algoritmos clássicos conhecidos atualmente.

3. Visão Geral do Algoritmo GNFS e Estrutura Matemática

O GNFS possui uma base matemática muito complexa e avançada. A ideia básica é uma extensão do Pequeno Teorema de Fermat e do Crivo Quadrático (QS), consistindo em encontrar um par não-trivial $(X, Y)$ que satisfaça a congruência $X^2 \equiv Y^2 \pmod n$ e $X \not\equiv \pm Y \pmod n$, para assim derivar um fator $\gcd(X-Y, n)$ de $n$.

No entanto, a verdadeira essência do GNFS não é fazer isso apenas no corpo dos números racionais $\mathbb{Q}$, mas sim buscar simultaneamente por “números suaves (Smooth numbers)” tanto em uma extensão de corpo chamada Corpo de Números Algébricos (Algebraic Number Field) $\mathbb{Q}(\alpha)$ quanto no corpo dos números racionais, e construir uma relação de congruência por meio de um homomorfismo.

O processo do GNFS é amplamente dividido em 5 fases.

graph TD A["Problema de fatoração de inteiros (entrada n)"] --> B["1. Seleção de polinômios (Polynomial Selection)"] B --> C["2. Processo de crivagem (Sieving Phase)"] C --> D["3. Filtragem (Filtering Phase)"] D --> E["4. Álgebra Linear (Linear Algebra Phase)"] E --> F["5. Raiz quadrada (Square Root Phase)"] F --> G["Saída dos fatores primos p, q"]

3.1 Fase 1: Seleção de polinômios (Polynomial Selection)

O sucesso do GNFS depende fortemente da seleção adequada dos polinômios. O objetivo é encontrar dois polinômios irredutíveis $f_1(x)$ (lado racional) e $f_2(x)$ (lado algébrico) que compartilham uma raiz comum $m$. Ou seja, $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$ satisfazendo.

Normalmente, um polinômio linear $f_1(x) = x - m$ é escolhido para o lado racional, e um polinômio mônico $f_2(x)$ de grau $d$ (tipicamente 5 ou 6) é escolhido para o lado algébrico. A abordagem mais clássica é o Método de base $m$ (Base-$m$ method). Escolhe-se um inteiro $m = \lfloor n^{1/(d+1)} \rfloor$ próximo à raiz $1/(d+1)$ de $n$ e expande-se $n$ na base $m$. $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ Com isso, obtemos o polinômio $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$. Claramente, $f_2(m) = n \equiv 0 \pmod n$.

Entretanto, em implementações modernas o Algoritmo de Kleinjung é utilizado. Ele busca polinômios cujos coeficientes não se tornem extremamente grandes (otimização de Skewness) enquanto otimiza propriedades algébricas (valor $E$ de Murphy e valor $\alpha$), facilitando a geração de números suaves durante o processo de crivagem. Esta etapa por si só requer uma enorme quantidade de recursos computacionais.

3.2 Fase 2: Processo de crivagem (Sieving Phase)

Uma vez que os polinômios são determinados, entra-se na fase de “Crivagem (Sieving)”, que é a fase mais exigente do ponto de vista computacional do algoritmo. Aqui, buscamos pares $(a, b)$. Este par deve ser coprimo entre si e é requerido que os dois valores seguintes sejam simultaneamente “suaves (Smooth)”.

Norma do lado racional: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
Norma do lado algébrico: $F_2(a, b) = b^d \cdot f_2(a/b)$

“Suave” significa que o valor pode ser fatorado apenas por números primos menores ou iguais a um limite especificado (Sieve bound). Uma base de fatores (Factor base) para o lado racional e outra para o lado algébrico são preparadas, e números suaves são encontrados eficientemente em um enorme espaço de busca utilizando uma técnica semelhante ao Crivo de Eratóstenes. Hoje, uma técnica chamada Crivo em Reticulado (Lattice Sieving) é dominante, onde se fixa um número primo específico $q$ e realiza-se a crivagem apenas em pares $(a, b)$ em um sub-reticulado no qual tanto o lado racional quanto o algébrico são múltiplos de $q$, alcançando assim uma eficiência extremamente alta.

3.3 Fase 3: Filtragem (Filtering Phase)

O número de relações suaves (relations) encontradas no processo de crivagem chega a centenas de milhões, ou até bilhões. No entanto, muitas destas contêm informações inúteis. O objetivo da filtragem é construir uma enorme matriz esparsa (Sparse Matrix) ao mesmo tempo que reduz a sua dimensionalidade ao máximo possível.

Especificamente, realizam-se as seguintes operações:

Remoção de singletons (Singleton removal): Excluir as relações que contêm fatores primos que aparecem apenas uma vez.
Remoção de cliques / Mesclagem (Clique removal / Merging): Multiplicar relações que possuem fatores primos que aparecem duas ou mais vezes, eliminando variáveis para reduzir para um sistema de equações de maior densidade, porém menor dimensionalidade.

Com isso, uma matriz com bilhões de linhas é comprimida em uma enorme matriz esparsa $\mathbf{A}$ (com elementos 0 e 1 sobre o corpo $\mathbb{F}_2$) de nível de dezenas de milhões de linhas.

3.4 Fase 4: Álgebra Linear (Linear Algebra Phase)

Aqui, buscamos um vetor de solução não trivial $\mathbf{x}$ para a equação $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$. Ou seja, é o problema de encontrar o espaço nulo à esquerda (Left Nullspace) de uma enorme matriz esparsa.

Devido ao tamanho extremo da matriz, é totalmente inviável calcular com a eliminação gaussiana padrão ($O(N^3)$). Portanto, utilizam-se métodos iterativos, que são um tipo de método de subespaço de Krylov. Historicamente, o Método Block Lanczos tem sido utilizado, mas em ambientes modernos de computação distribuída o Algoritmo de Block Wiedemann, que pode reduzir drasticamente a sobrecarga de comunicação, é o dominante.

O método Block Wiedemann calcula o polinômio mínimo a partir da matriz $\mathbf{A}$ e de sequências de vetores e constrói a base do espaço nulo utilizando o algoritmo de Berlekamp-Massey. Esse passo é extremamente difícil de paralelizar, o que exige redes de comunicação estreitamente acopladas em supercomputadores ou grandes clusters, sendo um dos maiores gargalos do GNFS.

3.5 Fase 5: Raiz quadrada (Square Root Phase)

A partir das soluções da álgebra linear, constrói-se um produto que é um “quadrado perfeito” em ambos os lados, o racional e o algébrico. No lado racional, $\prod (a-bm)$ torna-se o quadrado $X^2$ de um determinado inteiro $X$, enquanto no lado algébrico o produto dos ideais correspondentes torna-se um quadrado perfeito $\gamma^2$ no corpo de números algébricos. Ao calcular esse $\gamma$ no corpo de números algébricos e aplicar o homomorfismo ao anel dos inteiros racionais $\phi: \alpha \mapsto m \pmod n$, obtemos a congruência: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$ obtém-se.

O cálculo da raiz quadrada no corpo de números algébricos utiliza algoritmos complexos, como o Método de Montgomery, exigindo um profundo conhecimento em teoria algébrica dos números. Finalmente, $\gcd(X-Y, n)$ é calculado, e se um fator não trivial for obtido, a fatoração estará concluída.

4. Existe algum algoritmo clássico que supere o GNFS?

Até o momento, não foi descoberto nenhum algoritmo clássico que seja capaz de atingir uma complexidade assintótica abaixo de $L_n[1/3, c]$ para a fatoração de números inteiros gerais. No entanto, existem algumas tentativas e algoritmos derivados voltados a romper esses limites teóricos e práticos.

4.1 Crivo de Múltiplos Campos de Números (MNFS: Multiple Number Field Sieve)

Como uma abordagem estendida do GNFS, existe o Crivo de Múltiplos Campos de Números (MNFS) de D. Coppersmith. Enquanto o GNFS utiliza 2 polinômios (um lado racional e um algébrico), o MNFS utiliza múltiplos polinômios algébricos diferentes em conjunto com um único polinômio racional.

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

Ao usar múltiplos corpos algébricos, a probabilidade de “ser suave em qualquer um dos corpos algébricos” em cada etapa da crivagem aumenta drasticamente. Com essa abordagem, Coppersmith conseguiu reduzir ligeiramente a constante $c$ da complexidade $L_n[1/3, c]$. Especificamente, enquanto a constante no GNFS é $c = (64/9)^{1/3} \approx 1.923$, mostrou-se teoricamente que a complexidade pode ser reduzida até $c \approx 1.902$ ao otimizar o MNFS. No entanto, na prática, a sobrecarga de gerenciar múltiplos corpos é grande, e não houve grandes avanços definitivos em módulos RSA em escalas de uso no mundo real.

4.2 Algoritmos de classe $L_n[1/4]$ são possíveis?

O tema sobre “se um algoritmo com expoente $\alpha = 1/4$ existe”, quanto ao limite dos algoritmos clássicos de fatoração, tem sido debatido há muito tempo entre os matemáticos. O GNFS atual e suas derivações estão fortemente atrelados ao modelo de “busca por suavidade” usando crivos, e é amplamente acreditado que $\alpha = 1/3$ é o limite desse paradigma. Com base na análise das probabilidades de distribuição de números inteiros suaves utilizando a função de Dickman, acredita-se que não é possível superar a barreira de $O(L_n[1/3])$ com a combinação dos métodos de construção de campos algébricos e de crivos atuais, não importa o quanto se otimize.

Se um algoritmo $L_n[1/4]$ ou mesmo um algoritmo polinomial clássico existisse, dependeria de uma estrutura matemática inteiramente nova e inimaginável pela humanidade até então (como, por exemplo, a abordagem muito mais avançada de geometria algébrica, semelhante ao Algoritmo de Schoof para a criptografia de curvas elípticas), e não na abordagem de “base em suavidade” como no GNFS. No entanto, atualmente não há sinal disso.

5. O Grande Avanço da Computação Quântica: Algoritmo de Shor

Enquanto os computadores clássicos enfrentam a barreira de $L_n[1/3]$, o Algoritmo de Shor (Shor’s Algorithm), introduzido por Peter Shor em 1994, destruiu esta parede mudando fundamentalmente o modelo de computação em si.

5.1 O impacto do tempo polinomial quântico

O Algoritmo de Shor reduz o problema da fatoração a um “Problema de Busca de Ordem (Order Finding Problem)”. Dado um inteiro $a$, é o problema de encontrar o período (ordem) $r$ da função $f(x) = a^x \pmod n$. Um computador clássico leva um tempo exponencial para encontrar esse período, mas usando a Estimação de Fase Quântica (QPE: Quantum Phase Estimation) e a Transformada de Fourier Quântica (QFT: Quantum Fourier Transform) em um computador quântico, todas as superposições de estado (Superposition) podem ser avaliadas em paralelo, o que permite extrair o período $r$ com alta probabilidade.

Em termos de complexidade computacional, o tempo de execução do Algoritmo de Shor é de tempo polinomial quântico, especificamente o seguinte:

$$ O((\log n)^3) $$

Tendo em vista as implementações de circuitos otimizadas nos últimos anos, afirma-se que o tempo pode ser reduzido até $O((\log n)^2 \log \log n)$.

graph LR A["Algoritmo clássico (GNFS)"] -->|Limite| B["Tempo subexponencial L_n[1/3]"] C["Algoritmo quântico (Shor)"] -->|Avanço| D["Tempo polinomial O((log n)^3)"] B --> E["Uso contínuo de criptografia RSA (aumento do tamanho da chave)"] D --> F["Colapso completo da criptografia RSA"]

5.2 Tempo subexponencial clássico vs Tempo polinomial quântico

A diferença entre essas duas classes de complexidade tem um significado decisivo na segurança de criptografias no mundo real.

Por exemplo, considere a fatoração do RSA-2048 (um número composto de 2048 bits).

GNFS (Clássico): Substituindo $n \approx 2^{2048}$ em $L_n[1/3, 1.923]$, serão necessárias cerca de $2^{112}$ operações. Essa é uma quantidade de cálculos astronômica que demoraria mais que a idade do universo, mesmo se reuníssemos todos os recursos de computação do planeta.
Algoritmo de Shor (Quântico): No algoritmo $O((\log n)^3)$, seriam necessárias apenas cerca de $2048^3 \approx 8.5 \times 10^9$ operações em portas lógicas. Isso significa que a computação poderia ser concluída de apenas algumas horas a alguns dias se houvesse o hardware adequado (um computador quântico universal capaz de corrigir erros com alguns milhões de qubits físicos).

A mudança de paradigma da complexidade subexponencial com “expoente $\alpha=1/3$” para “tempo polinomial” anula a estratégia tradicional de criptografia que consiste em garantir a segurança por meio do alongamento do comprimento da chave.

6. Conclusão: Perspectivas para a próxima geração

O consenso atual na comunidade científica em relação à pergunta “Existe algum algoritmo clássico que supere o GNFS?” é o seguinte:

Aprimoramentos práticos continuam, mas não há um grande salto assintótico: As tentativas de melhorar o fator $c$ do GNFS através do MNFS, da otimização na seleção de polinômios, da paralelização do Método de Block Wiedemann, etc., seguem ocorrendo. Contudo, considera-se extremamente improvável que seja descoberto um algoritmo clássico abaixo de $\alpha = 1/3$.
A segurança do RSA em computadores clássicos permanece forte: A complexidade computacional do GNFS continua enorme, e os RSA-2048 e RSA-4096 permanecerão protegidos contra ataques vindos de computadores clássicos durante as próximas décadas.
A verdadeira ameaça é o algoritmo quântico: O Algoritmo de Shor, baseado nos princípios da mecânica quântica, ultrapassou os limites da complexidade computacional. Como resultado, o mundo é obrigado a realizar a transição para a Criptografia Pós-Quântica (PQC). A fronteira da criptografia de hoje encontra-se em novos problemas matemáticos, como a criptografia baseada em reticulados e a criptografia baseada em hashes, as quais são consideradas difíceis de se decifrar até para computadores quânticos (ou seja, não possuem resolução no tempo polinomial).

O Crivo Geral dos Campos de Números (GNFS) é uma das maiores conquistas matemáticas alcançadas pela humanidade ao desafiar os limites do design de algoritmos e matemática clássica. Compreender a profunda estrutura matemática do GNFS não é apenas aprender sobre a história da criptanálise, é também uma jornada de exploração intelectual que nos permite tocar na beleza da teoria da complexidade computacional e da teoria algébrica dos números. Até ao dia em que os computadores quânticos se tornarem práticos, o GNFS deverá manter a sua coroa como o algoritmo de fatoração de inteiros mais poderoso.

【Ilustrado PQC】Comparação dos principais algoritmos de criptografia pós-quântica

Fri, 11 Sep 2026 07:00:00 +0900

1. Introdução: A “crise da criptografia” trazida pelos computadores quânticos

Na sociedade da internet moderna, a tecnologia de criptografia de chave pública é infraestrutura indispensável para proteger a confidencialidade das comunicações e a integridade dos dados. A criptografia RSA e a criptografia de curva elíptica (ECC), amplamente utilizadas hoje, dependem de barreiras matemáticas, respectivamente a “dificuldade de fatoração de números compostos gigantescos” e a “dificuldade do problema do logaritmo discreto em curvas elípticas”, para garantir a segurança. Em computadores clássicos (os computadores que usamos hoje, incluindo supercomputadores), está provado que resolver esses problemas matemáticos levaria mais tempo do que a idade do universo, o que tem sido a base de sua segurança.

No entanto, essa premissa robusta está prestes a ser fundamentalmente derrubada pelo progresso na teoria e aplicação prática dos computadores quânticos. O “Algoritmo de Shor”, publicado em 1994 pelo criptógrafo Peter Shor, provou teoricamente que problemas de fatoração de primos e logaritmos discretos podem ser resolvidos em “tempo polinomial” executando-os em um computador quântico universal tolerante a falhas (CRQC: Cryptographically Relevant Quantum Computer) com desempenho suficiente. Isso significa que toda a criptografia de chave pública atualmente em uso será neutralizada.

graph TD A["Computador quântico de grande escala (CRQC)"] -->|Execução| B["Algoritmo de Shor"] B -->|Decodificação em tempo polinomial| C["Problema de fatoração (RSA)"] B -->|Decodificação em tempo polinomial| D["Problema de logaritmo discreto (ECC / ECDSA)"] C --> E["Interceptação, alteração de dados e falsificação de comunicação criptografada"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

É muito perigoso pensar que “não há problema porque a conclusão em grande escala dos computadores quânticos ainda está a décadas de distância”. Isso ocorre porque o método de ataque chamado Store Now, Decrypt Later (SNDL: Armazene agora, descriptografe depois) já se tornou uma ameaça real. Trata-se de um ataque em que nações maliciosas ou organizações de hackers armazenam grandes quantidades de dados de comunicação atualmente criptografados (como o tráfego TLS) e os descriptografam todos no momento em que computadores quânticos poderosos se tornarem disponíveis no futuro. Segredos de estado, informações de infraestrutura e dados médicos que devem ser protegidos a longo prazo já estão expostos a essa ameaça.

Além disso, para criptografia de chave simétrica (como AES) e funções de hash (como SHA-256), existe o Algoritmo de Grover, descoberto em 1996. Isso reduz a complexidade computacional dos ataques de força bruta (brute force) à sua raiz quadrada. Em outras palavras, o nível de segurança do AES-128 é efetivamente reduzido pela metade, para 2 à potência de 64, portanto, na era quântica, recomenda-se usar chaves mais longas e comprimentos de hash como AES-256 e SHA-384.

A Criptografia Pós-Quântica (PQC), baseada em novos problemas matemáticos difíceis de decifrar, mesmo usando computadores quânticos, nasceu para combater essa crise criptográfica sem precedentes. Neste artigo, com base nos resultados do processo de padronização PQC liderado pelo Instituto Nacional de Padrões e Tecnologia dos EUA (NIST), explicaremos os principais algoritmos PQC em detalhes extremos, desde sua base matemática até seus mecanismos e comparação de arquitetura.

2. Todo o escopo e história do projeto de padronização PQC do NIST

A transição da tecnologia de criptografia leva anos ou até décadas, incluindo o redesenho de protocolos, atualizações de sistema, substituição de hardware, etc. Por esse motivo, criptógrafos de todo o mundo vêm avançando na pesquisa PQC desde cedo. O NIST dos EUA desempenhou um papel central nisso. O NIST abriu o processo de padronização PQC ao público em 2016 e aceitou propostas de algoritmos de criptografia completamente novos da comunidade criptográfica global.

As duas categorias principais para padronização foram as seguintes:

Criptografia de chave pública / Mecanismo de encapsulamento de chaves (KEM: Key Encapsulation Mechanism): Um mecanismo para compartilhar de forma segura uma chave simétrica para criptografar o caminho de comunicação, como em conexões TLS.
Assinaturas digitais (Digital Signatures): Um mecanismo para provar que os dados não foram alterados e que não há falsificação pelo remetente (autenticidade) em atualizações de software e certificados digitais.

Após quase 6 anos de feroz avaliação, análise e competição criptoanalítica (Rodada 1 à Rodada 3), alguns algoritmos também foram submetidos a uma avaliação adicional na Rodada 4. Como resultado, em 2024, os seguintes algoritmos foram oficialmente emitidos como Padrões Federais de Processamento de Informação (FIPS) e foram estabelecidos como padrões globais futuros.

FIPS 203 (ML-KEM): KEM baseado em CRYSTALS-Kyber
FIPS 204 (ML-DSA): Assinatura digital baseada em CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Assinatura baseada em hash sem estado baseada em SPHINCS+
(Planejado para formulação futura) FN-DSA: Assinatura digital baseada em FALCON

Cada um desses algoritmos selecionados se baseia em diferentes “problemas de dificuldade” matemáticos, garantindo diversidade (Crypto Agility) de modo que, mesmo se uma vulnerabilidade fatal for descoberta em um algoritmo no futuro, o sistema inteiro não entrará em colapso. No processo de padronização, a criptografia baseada em reticulados (Lattice-based cryptography) assumiu o papel principal principalmente do ponto de vista do desempenho, mas a criptografia baseada em hash e a criptografia baseada em código foram adotadas como backups fortes.

3. Classificação das principais abordagens matemáticas para PQC

Os algoritmos PQC são categorizados principalmente nas 5 áreas a seguir com base nos problemas matemáticos em que baseiam sua segurança. Neste artigo, nos aprofundaremos principalmente nas três primeiras.

Criptografia baseada em reticulados (Lattice-based Cryptography): Baseia-se no Problema do Vetor Mais Curto (SVP) e no Problema do Vetor Mais Próximo (CVP) em espaços de reticulados multidimensionais, e no problema LWE derivado deles. É o centro da padronização do NIST, incluindo Kyber, Dilithium e FALCON. Possui o melhor equilíbrio entre velocidade de processamento, tamanho da chave pública e tamanho do texto cifrado, sendo adequado para uso geral.
Criptografia baseada em hash (Hash-based Cryptography): Baseia sua segurança unicamente na “resistência à colisão” e “unidirecionalidade” das funções de hash criptográficas (como SHA-2 e SHAKE). É aplicável apenas a assinaturas digitais (SPHINCS+, etc.), mas tem a prova matemática mais forte de segurança e é caracterizada por uma resistência extremamente alta a ataques matemáticos desconhecidos.
Criptografia baseada em código (Code-based Cryptography): Baseado na teoria de códigos de correção de erros, depende da dificuldade do Problema de Decodificação de Síndrome (Syndrome Decoding Problem). O Classic McEliece, proposto na década de 1970, é representativo e, embora tenha uma longa história e segurança comprovada, o tamanho da chave pública é extremamente grande, chegando a megabytes.
Criptografia polinomial multivariada (Multivariate Polynomial Cryptography): Baseia-se na dificuldade de encontrar soluções para um sistema de equações quadráticas simultâneas multivariadas sobre um corpo finito (problema MQ). Foi proposto principalmente para assinaturas digitais (como Rainbow), mas durante a rodada final do NIST, descobriu-se um método de ataque poderoso que o decifrou em alguns dias em um único PC, levando muitos algoritmos a serem retirados da padronização.
Criptografia baseada em isogenia (Isogeny-based Cryptography): Baseado no problema de encontrar caminhos em grafos de isogenia (Isogeny) de curvas elípticas. Com um tamanho de chave muito pequeno, era esperado que fosse o sucessor legítimo da ECC, mas seu candidato final, “SIKE”, foi completamente decifrado em poucas horas num PC normal usando matemática clássica (como o ataque de Castryck-Decru) em 2022, resultando num final dramático que simboliza a dificuldade e o terror do design de PQC.

4. O abismo da criptografia baseada em reticulados: A base matemática do problema LWE e do Module-LWE

Atualmente considerada a mais promissora e o centro da padronização, a criptografia baseada em reticulados. Na raiz de sua segurança está o Problema LWE (Learning with Errors: Aprendizado com Erros). Proposto por Oded Regev em 2005, essa conquista inovadora lhe rendeu o Prêmio Gödel. A compreensão moderna da PQC é impossível sem entender o problema LWE.

4.1. O que é o problema LWE (Learning with Errors)?

Primeiro, vamos considerar um sistema simples de equações lineares. Suponha que, sob um certo módulo $q$ (módulo $q$), temos uma matriz aleatória conhecida $A$, um vetor secreto desconhecido $\vec{s}$, e seu produto $\vec{b}$ é dado.

$$ \vec{b} = A\vec{s} \pmod q $$

Neste caso, é fácil encontrar o desconhecido $\vec{s}$ a partir das informações públicas $A$ e $\vec{b}$. Usando o clássico “método de eliminação de Gauss”, $\vec{s}$ pode ser facilmente calculado em tempo polinomial.

No entanto, adicionar um “pequeno erro (ruído) intencional” a esta equação aumenta drasticamente a dificuldade do problema. Este é o problema LWE.

Preparamos um vetor secreto desconhecido $\vec{s} \in \mathbb{Z}_q^n$ e uma matriz escolhida aleatoriamente $A \in \mathbb{Z}_q^{m \times n}$. Além disso, preparamos um vetor de erro $\vec{e} \in \mathbb{Z}_q^m$, escolhido de acordo com uma distribuição normal ou binomial, cujos “valores dos elementos são suficientemente pequenos”, e calculamos $\vec{b}$ da seguinte forma:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

O Problema LWE de Busca (Search LWE) é o problema de “encontrar a informação secreta $\vec{s}$ a partir da informação pública $(A, \vec{b})$”. Devido à existência deste erro $\vec{e}$, se você tentar métodos algébricos como a eliminação de Gauss, o erro $\vec{e}$ será amplificado como uma bola de neve durante a adição e subtração das equações, tornando-se indistinguível de valores aleatórios e, em última análise, colapsando.

A maravilha do problema LWE é que existe uma prova teórica forte (redução) de que, a menos que haja um algoritmo quântico que possa resolver os problemas de complexidade do pior caso (Worst-case hardness) no reticulado, como o GapSVP (Problema de Decisão do Vetor Mais Curto) ou SIVP (Problema de Vetores Independentes Mais Curtos), o problema LWE também não pode ser resolvido no caso médio (Average-case). Em outras palavras, mesmo chaves criptográficas geradas aleatoriamente têm garantia de forte segurança apoiada por limites teóricos.

4.2. Aumento drástico na eficiência através do Ring-LWE e Module-LWE

O problema LWE normal (Standard LWE) tem uma base de segurança muito clara, mas o tamanho da matriz $A$ se torna muito grande, resultando em chaves na ordem de megabytes, tornando-o impraticável. A abordagem proposta para resolver isso foi usar anéis polinomiais (Polynomial Rings) para introduzir estrutura algébrica.

No problema Ring-LWE, em vez de simples vetores e matrizes, usamos os elementos (polinômios) de um anel polinomial $R_q$. O anel polinomial ciclotômico a seguir é comumente usado nos padrões do NIST:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Aqui, $n$ é uma potência de 2 (por exemplo: 256) e $q$ é um número primo apropriado. Neste anel, calculamos $b = a \cdot s + e \pmod q$ usando elementos $a, s, e \in R_q$. Como um único polinômio $a$ tem $n$ coeficientes, os dados podem ser consideravelmente compactados, e usando a NTT (Transformada Teórica dos Números: Number Theoretic Transform), que é uma versão de corpo finito da Transformada Rápida de Fourier (FFT), a multiplicação de polinômios torna-se ultrarrápida com complexidade $O(n \log n)$.

No entanto, o Ring-LWE tinha a preocupação de que “vulnerabilidades desconhecidas poderiam existir devido à estrutura algébrica especial do anel”. Além disso, para alterar o nível de segurança (por exemplo, equivalente a AES-128, 192, 256), o próprio grau do polinômio $n$ precisava ser alterado, e com isso, toda a implementação, como o algoritmo NTT, tinha que ser reescrita, apresentando um desafio de engenharia.

Portanto, o problema Module-LWE (M-LWE) foi adotado pelos algoritmos padronizados Kyber e Dilithium. Module-LWE é um compromisso, situando-se exatamente entre o Standard LWE, sem estrutura, e o Ring-LWE, excessivamente estruturado. Ele usa uma matriz $k \times k$ (módulo) cujos elementos são componentes do anel polinomial $R_q$.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

A maior vantagem do Module-LWE é que, mantendo o grau do polinômio $n$ constante ($n=256$ no padrão NIST), o nível de segurança pode ser facilmente escalado simplesmente mudando a dimensão da matriz $k$. Por exemplo, no caso do Kyber, a dimensão $k$ é ajustada da seguinte forma:

Kyber512 (Nível 1): $k = 2$ (equivalente a AES-128)
Kyber768 (Nível 3): $k = 3$ (equivalente a AES-192)
Kyber1024 (Nível 5): $k = 4$ (equivalente a AES-256)

Isso tornou possível reutilizar 100% do código NTT subjacente e circuitos de hardware de operações polinomiais em todos os níveis de segurança, melhorando drasticamente a segurança e a eficiência da implementação.

5. CRYSTALS-Kyber (ML-KEM): O Mecanismo de Encapsulamento de Chaves de Próxima Geração

O CRYSTALS-Kyber, oficialmente padronizado como FIPS 203 (ML-KEM), é um mecanismo de encapsulamento de chaves (KEM) baseado no problema Module-LWE descrito acima. No futuro, se tornará o padrão global de fato para compartilhar chaves de sessão com segurança em TLS 1.3, SSH, etc.

5.1. Arquitetura do KEM (Key Encapsulation Mechanism)

Na era da PQC, a abordagem de encapsulamento de KEM torna-se padrão, em vez da abordagem direta como no RSA, onde “o cliente cria uma chave simétrica e a criptografa com a chave pública do servidor e a envia”.

sequenceDiagram participant Client as "Cliente (Alice)" participant Server as "Servidor (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Gera a chave secreta (sk) e a chave pública (pk)" Client->>Server: "Envia a chave pública (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Gera uma chave simétrica aleatória (K)" Server->>Server: "Encapsula K com pk para criar o texto cifrado (c)" Server->>Client: "Envia o texto cifrado (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Descriptografa o texto cifrado (c) usando a chave secreta (sk)" Client->>Client: "Desencapsula para extrair a chave simétrica (K)" Note over Client, Server: "Inicia a comunicação criptografada usando a chave simétrica compartilhada (K) via AES, etc."

5.2. O mecanismo algorítmico interno do Kyber e a Transformada de Fujisaki-Okamoto

O design do Kyber é extremamente refinado. Primeiro, constrói-se um esquema de criptografia de chave pública (Kyber.CPAPKE) seguro apenas contra CPA (Ataque de Texto Simples Escolhido). Em seguida, aplicando um método criptográfico muito poderoso chamado Transformada de Fujisaki-Okamoto (Fujisaki-Okamoto Transform), ele é atualizado para um KEM completo, seguro até mesmo contra CCA (Ataque de Texto Cifrado Escolhido Adaptativo).

Os mecanismos principais de criptografia e descriptografia do CPAPKE são os seguintes:

Geração de Chave (Key Generation):
- A partir de um valor semente aleatório, gera uma matriz $A \in R_q^{k \times k}$ no domínio NTT. O módulo $q$ usado é $3329$.
- Um vetor secreto $\vec{s}$ e um vetor de erro $\vec{e}$ com coeficientes pequenos são amostrados de uma distribuição binomial centralizada (CBD).
- Calcula $\vec{t} = A\vec{s} + \vec{e}$. A chave pública é $(A, \vec{t})$ e a chave secreta é $\vec{s}$. (Na prática, $A$ é revelado como um valor de semente para economizar largura de banda).
Criptografia (Encryption):
- Uma mensagem de 32 bytes a ser compartilhada (o material para a chave simétrica) $m$ é codificada em um polinômio.
- Um novo vetor aleatório $\vec{r}$ e pequenos erros $\vec{e_1}, e_2$ são gerados.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- O texto cifrado é $(\vec{u}, v)$.
Descriptografia (Decryption):
- O receptor calcula $v - \vec{s}^T\vec{u}$.
- Expandindo esta fórmula, obtemos o seguinte: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Substituindo $\vec{t} = A\vec{s} + \vec{e}$ aqui, o termo principal $\vec{s}^TA^T\vec{r}$ se cancela.
- O que resta é $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- O termo entre parênteses é “o produto ou soma de pequenos erros”, então permanece um valor pequeno (ruído) como um todo. Portanto, julgando pelos limites se cada coeficiente está perto de $0$ ou de $q/2$, os bits (0 ou 1) da mensagem original $m$ podem ser perfeitamente restaurados sem erros.

A maior força do Kyber é sua impressionante velocidade de processamento e tamanho de chave moderado. Para o Kyber768, o tamanho da chave pública é de 1.184 bytes e o tamanho do texto cifrado é de 1.088 bytes. Embora sejam maiores em comparação com o RSA-3072 (tamanho da chave em torno de 384 bytes), eles podem caber dentro do MTU (Maximum Transmission Unit) das comunicações modernas da internet sem fragmentação de pacotes, tendo um efeito adverso quase nulo na latência da rede.

6. CRYSTALS-Dilithium (ML-DSA): Assinatura digital de uso geral baseada em reticulado

Na padronização de assinaturas digitais, algoritmos com diferentes filosofias de design competiram mesmo na mesma abordagem de criptografia baseada em reticulado. Dentre eles, CRYSTALS-Dilithium foi selecionado como FIPS 204 (ML-DSA) para ser a assinatura digital de uso geral.

6.1. Paradigma Fiat-Shamir com Abortos

Como o Kyber, Dilithium é um esquema de assinatura digital baseado no problema Module-LWE (e no problema Module-SIS). O design é baseado no paradigma extremamente importante chamado “Fiat-Shamir with Aborts (Transformada de Fiat-Shamir com Interrupções)”.

A transformada Fiat-Shamir em si é um método padrão para converter um protocolo de prova de conhecimento zero interativo em uma assinatura digital não interativa. O provador (assinante) gera um compromisso $y$, calcula $w = Ay$, passa-o por uma função de hash para obter um desafio aleatório $c$ e calcula a resposta $z = y + cs$.

No entanto, quando isso é aplicado de forma simples à criptografia baseada em reticulado, a distribuição da resposta $z$ torna-se enviesada dependendo do valor da chave secreta $s$, levando a um problema fatal (vazamento matemático do tipo canal lateral) em que as informações da chave secreta $s$ vazam gradualmente para um invasor que observa um grande número de assinaturas.

A equipe de design do Dilithium (Lyubashevsky et al.) introduziu um método chamado “Rejection Sampling (Amostragem de Rejeição)”: se os coeficientes do resultado do cálculo da assinatura $z$ não se enquadrarem em um intervalo de limite de segurança predefinido, todo o processo de assinatura é abortado, e os cálculos são reiniciados desde o início usando um novo número aleatório $y$.

Como resultado, a assinatura final $z$ tem uma distribuição perfeitamente uniforme, completamente independente da chave secreta, evitando totalmente qualquer vazamento matemático de informações.

6.2. Vantagens e facilidade de implementação do Dilithium

Uma grande vantagem de design do Dilithium é que ele não usa de forma alguma “amostragem de distribuição gaussiana” ou “operações de ponto flutuante” complexas no processo de geração de assinatura. Como pode ser implementado apenas com amostragem de distribuição uniforme, aritmética modular de inteiros simples, NTT e funções de hash (SHAKE), é fácil de implementar de forma segura e com tempo constante (Constant-time) em uma ampla variedade de ambientes, de microcontroladores embarcados a servidores em nuvem. Isso lhe dá uma forte resistência contra ataques físicos de canal lateral, como ataques de tempo.

7. FALCON (FN-DSA): Assinatura de reticulado extremamente compacta

O NIST selecionou FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU), outra assinatura baseada em reticulado com características diferentes do Dilithium, como um candidato de padronização (atualmente em elaboração como FN-DSA).

7.1. Reticulado NTRU e Amostragem Gaussiana

A maior característica do FALCON é que ele usa reticulados NTRU (N-th degree Truncated polynomial Ring Units), com uma longa história que remonta a 1996, em vez do problema LWE. Além disso, adota o paradigma “Hash-and-Sign (Fazer hash e assinar)” baseado na estrutura GPV (Gentry-Peikert-Vaikuntanathan).

No Hash-and-Sign, o valor do hash da mensagem é o ponto alvo no espaço, e o ponto no reticulado mais próximo desse ponto (a solução aproximada para o Problema do Vetor Mais Próximo) torna-se a assinatura. Isso requer a amostragem de pontos de acordo com uma distribuição gaussiana discreta, usando uma “base curta e de boa qualidade” que é a chave secreta.

O FALCON acelerou drasticamente esse cálculo pesado usando uma técnica chamada “Ortogonalização Rápida de Fourier (Fast Fourier Orthogonalization: FFO)”.

7.2. Vantagens e Desvantagens do FALCON

A vantagem esmagadora do FALCON é que o tamanho da assinatura e da chave pública são extremamente pequenos (compactos). Enquanto o tamanho da assinatura do Dilithium3 é de cerca de 3.309 bytes, o tamanho da assinatura do FALCON-512 é de apenas cerca de 666 bytes. A chave pública também é bem pequena, 897 bytes, tornando-se uma salvação em ambientes com limitações severas de largura de banda, dispositivos IoT e determinados protocolos de rede.

No entanto, há uma desvantagem significativa. Como a amostragem gaussiana discreta, que requer cálculos complexos de ponto flutuante (64 bits IEEE 754), é obrigatória na geração de assinaturas, é extremamente difícil conseguir uma implementação em tempo constante para evitar o vazamento de tempo, e o código se torna massivo. Devido a isso, o FALCON é posicionado como um algoritmo altamente especializado para aplicações específicas, ao invés de uso geral (como o Dilithium).

graph LR A["Requisitos de assinatura digital"] --> B{"Qual é a restrição prioritária?"} B -->|"Simplicidade de implementação, uso geral, facilidade de tempo constante"| C["Dilithium (ML-DSA)"] B -->|"Minimizar largura de banda, compactação do tamanho de dados"| D["FALCON (FN-DSA)"] C --> E["Certificados TLS de uso geral, assinatura digital de software"] D --> F["Protocolos com limitações rigorosas de tamanho de pacote, ambientes especiais"]

8. SPHINCS+ (SLH-DSA): Assinatura baseada em hash que ostenta a maior segurança

Em preparação para o pior cenário, onde a segurança da criptografia baseada em reticulados seja no futuro quebrada por avanços de matemáticos geniais, o NIST estabeleceu o FIPS 205 (SLH-DSA), ou seja, SPHINCS+, como padrão, possuindo uma abordagem completamente diferente da criptografia de reticulado.

O SPHINCS+ é classificado como uma assinatura baseada em hash. O fundamento para sua segurança depende de um único ponto: “a função hash criptográfica usada (como SHA-2 ou SHAKE256) tem resistência a colisões e unidirecionalidade”. Como não depende de problemas matemáticos com uma estrutura algébrica específica, como LWE ou fatoração, ele possui uma segurança extremamente robusta (a segurança mais conservadora): não importa quão poderosos os algoritmos quânticos se tornem no futuro, isso pode ser contra-atacado simplesmente estendendo o comprimento da saída da função hash.

8.1. Arquitetura Stateless com WOTS+ e FORS

O histórico das assinaturas baseadas em hash é antigo, remontando à Assinatura Lamport e à Assinatura de Uso Único de Winternitz (WOTS) da década de 1970. Eram chaves descartáveis que “podiam ser usadas para assinar com segurança apenas uma vez”. Para permitir o uso múltiplo, algoritmos como XMSS (eXtended Merkle Signature Scheme) e LMS foram desenvolvidos, combinando a Árvore de Merkle para gerenciar um número infinito de chaves descartáveis com um único hash raiz.

No entanto, XMSS e LMS tinham uma falha grave: eram “Stateful (com retenção de estado)”. Exigia-se gravar o estado do índice de “qual chave descartável foi usada” na memória não-volátil rigorosamente a cada assinatura. Se, por exemplo, ao restaurar um snapshot de uma máquina virtual, o estado retrocedesse e a mesma chave fosse usada duas vezes, a chave secreta vazaria instantaneamente e o sistema entraria em colapso.

O SPHINCS+ é uma assinatura baseada em hash “Stateless (sem retenção de estado)” que resolve essa complexidade do gerenciamento de estado. A tecnologia principal é a seguinte combinação:

WOTS+ (Winternitz One-Time Signature Plus): Uma assinatura básica de uso único.
FORS (Forest of Random Subsets): Tecnologia de Assinatura de Poucas Vezes (Few-Time Signature). A segurança é mantida mesmo se a mesma chave for reutilizada algumas vezes.
Hyper-Tree (Estrutura de árvore gigante): Uma estrutura massiva com Árvores de Merkle sobrepostas em múltiplas camadas.

Na execução da assinatura, em vez de gerenciar o estado, o SPHINCS+ seleciona aleatoriamente usando números pseudoaleatórios uma das enormes quantidades de chaves FORS na base da Hyper-Tree e assina com ela. Como o número de folhas da árvore é astronomicamente grande, a probabilidade de escolher a mesma chave duas vezes por acaso (colisão) é baixa o suficiente para ser ignorada, realizando assim a propriedade stateless.

A única e maior fraqueza do SPHINCS+ é o tamanho gigantesco de suas assinaturas. Dependendo dos parâmetros, o tamanho pode variar de 17 kilobytes a 49 kilobytes, e a velocidade de geração de assinatura é esmagadoramente mais lenta em comparação com a criptografia de reticulado. Assim, o SPHINCS+ se destina a usos onde as assinaturas não são muito frequentes e a segurança absoluta de longo prazo é fortemente exigida, como assinatura para atualizações de software ou certificados de Autoridade de Certificação (CA) Raiz, ao invés da navegação web do dia-a-dia.

9. Criptografia baseada em código: O bom e velho gigante Classic McEliece

Uma abordagem importante que ainda está sendo avaliada como candidato final da Rodada 4 no processo de padronização do NIST é o Classic McEliece, uma criptografia baseada em código.

Proposto em 1978 por Robert McEliece, este algoritmo, juntamente com o RSA, é um dos mais antigos na história da criptografia de chave pública. Utiliza “Códigos de Goppa”, um código geométrico algébrico. Baseia-se no “Problema de Decodificação de Síndrome (Syndrome Decoding Problem)”, em que a mensagem é criptografada adicionando um erro intencional (vetor de ruído), e apenas aquele com a matriz de verificação de paridade do código de Goppa como chave secreta pode usar recursos poderosos de correção de erros para remover o ruído e recuperar a mensagem original.

$$ \vec{c} = \vec{m} G + \vec{e} $$

(Onde $G$ é a matriz geradora codificada (scrambled) atuando como chave pública, e $\vec{e}$ é o vetor de erro com peso $t$)

O que é mais incrível no Classic McEliece é o seu retrospecto avassalador: apesar de mais de 40 anos desde a sua proposta, e sujeito a intensas pesquisas de criptoanálise em todo o mundo, nenhuma vulnerabilidade fundamental foi descoberta. Ele tem a “segurança robusta mais bem comprovada pelo tempo” na PQC.

Além disso, tem a vantagem de um tamanho de texto cifrado extremamente pequeno (apenas cerca de 100 a 200 bytes). No entanto, há a desvantagem fatal de que o tamanho da chave pública chega à ordem de megabytes (MB). Mesmo no nível de segurança mais baixo (equivalente ao AES-128), a chave pública é de cerca de 250 KB e excede 1 MB nos níveis mais altos.

Portanto, não é aplicável em cenários onde a chave pública é transmitida pela rede em toda comunicação, como no handshake TLS. No entanto, em casos de uso especiais onde a chave pública pode ser pré-implantada no sistema (hardcoded), como na troca de chaves pré-compartilhadas em VPNs, chaves públicas no firmware ou comunicações por satélite, continua a ser investigada como uma escolha extremamente promissora devido à sua sólida segurança.

10. Comparação de desempenho de cada algoritmo PQC e trade-offs

Aqui está um resumo das características de desempenho nos níveis comuns de segurança (níveis 2 a 3 do NIST, equivalentes ao AES-128 a 192) para os principais algoritmos explicados até agora.

Algoritmo (Nome padrão)	Categoria	Base Matemática	Tamanho da chave pública	Tamanho da chave secreta	Tamanho texto cifrado/assin.	Tendência da vel. de processamento	Principais características e usos
Kyber768 (ML-KEM)	KEM	Module-LWE	1.184 Bytes	2.400 Bytes	1.088 Bytes	Muito rápida	Melhor equilíbrio de tamanho e velocidade. Padrão genérico de KEM para TLS 1.3, etc.
Dilithium3 (ML-DSA)	Assinatura	Module-LWE	1.952 Bytes	4.032 Bytes	3.309 Bytes	Geração e verificação rápidas	Implementação simples. Padrão genérico de assinatura digital.
FALCON-512 (FN-DSA)	Assinatura	Reticulado NTRU	897 Bytes	1.281 Bytes	666 Bytes	Geração de assin. um pouco lenta, verificação ultrarrápida	Tamanho de assinatura mínimo. Porém, exige ponto flutuante. Focado em sistemas embarcados/IoT.
SPHINCS+ (SLH-DSA)	Assinatura	Função Hash	32 Bytes	64 Bytes	Aprox. 17.000 Bytes	Geração muito lenta	Risco quase nulo de colapso matemático. Uso para alta segurança como certificados raiz.
Classic McEliece	KEM	Código Goppa	Aprox. 1,04 MB	13.568 Bytes	188 Bytes	Encapsulamento rápido	40 anos de histórico de segurança. Chave pública imensa. Para ambientes com hardcode.

Compreendendo os trade-offs

No mundo PQC, não existe um único algoritmo mágico que seja “pequeno em tamanho, rápido em velocidade e com garantia matemática perfeita”.

Padrões da Internet (Kyber / Dilithium): Possuem o melhor equilíbrio de desempenho, e são os mais adequados para um substituto direto (drop-in replacement) dos atuais RSA/ECC.
Conservadorismo Final (SPHINCS+): Selecionado quando você deseja uma garantia absoluta (seguro) contra avanços matemáticos futuros, mesmo com o sacrifício do tamanho dos dados e da velocidade de processamento.
Para ambientes especiais (FALCON / Classic McEliece): Armas de especialização escolhidas com base nas restrições do ambiente, como quando a largura de banda de comunicação é extremamente restrita ou quando a pré-distribuição é possível.

11. Desafios de implementação prática e a solução realística da “Criptografia Híbrida”

Com a conclusão da padronização pelo NIST e a emissão oficial do FIPS, a transição PQC das infraestruturas de TI mundiais (migração PQC) começou a sério. O navegador Chrome do Google, o iMessage da Apple (Protocolo PQ3), provedores de rede como Cloudflare, entre outros, já integraram o suporte PQC em seus protocolos e iniciaram operações reais.

Porém, existe um risco muito elevado em realizar uma transição completa e imediata para novos algoritmos de criptografia. Se, por exemplo, um matemático genial descobrir uma falha fatal de ataque (uma vulnerabilidade matemática decifrável até mesmo em um computador clássico) na criptografia de reticulado como o Kyber nos próximos anos, todo o sistema que depende dele será exposto instantaneamente.

Uma abordagem realística e recomendada para mitigar este risco de incerteza é a “Criptografia Híbrida (Hybrid Cryptography)”.

Na criptografia híbrida, você usa simultaneamente a criptografia clássica com longo histórico de confiabilidade (por exemplo: criptografia de curva elíptica como X25519) e o novo PQC (por exemplo: Kyber768) para realizar a troca de chaves. Os componentes de chaves comuns são gerados de forma independente por cada algoritmo e, finalmente, as duas partes são combinadas por meio de uma Função de Derivação de Chave (KDF) segura para gerar o segredo mestre final.

graph TD A["Cliente"] -->|① Envia chave pública X25519 + chave pública Kyber| B["Servidor"] B -->|② Retorna chave compartilhada X25519 + texto cifrado encapsulado Kyber| A A --> C{"Derivação do Segredo Mestre (KDF)"} B --> C C -->|Entrada: (chave comum X25519) || (chave comum Kyber)| D["Chave de comunicação segura (AES-256 / ChaCha20)"] D -->|"Resistente às ameaças quânticas e às vulnerabilidades clássicas"| E["Comunicação segura por criptografia híbrida (TLS 1.3)"]

Isso realiza uma postura de segurança robusta de dois níveis: “Mesmo que um computador quântico seja construído e a ECC seja quebrada, o Kyber protegerá a comunicação”, e inversamente, “Mesmo que uma falha matemática desconhecida seja descoberta no Kyber, a ECC protegerá a comunicação”. Como exemplo representativo, existe o rascunho X25519MLKEM768 (antigo X25519Kyber768) sendo padronizado na IETF, e a comunicação entre os navegadores Web atuais e servidores de ponta já é realizada usando exatamente esse método híbrido.

Além disso, na concepção do sistema, o conceito de “Crypto Agility (Agilidade Criptográfica)” – a arquitetura que permite não depender excessivamente de um algoritmo de criptografia específico e de poder mudar rapidamente para outro algoritmo (por exemplo, de Kyber para McEliece, de Dilithium para SPHINCS+) se um algoritmo for quebrado – se tornará um requisito indispensável para o desenvolvimento de sistemas no futuro.

12. Conclusão: Uma Nova Fronteira Tecnológica Criptográfica

Ironia do destino, o computador quântico, uma tecnologia dos sonhos da humanidade, tornou-se a maior ameaça a romper as paredes defensivas matemáticas, a “fatoração” e o “problema do logaritmo discreto”, nas quais confiamos por muitos anos. No entanto, criptógrafos de todo o mundo, sem se renderem, abriram domínios matemáticos multidimensionais muito mais profundos e complexos baseados em teorias de reticulados, árvores de funções hash e códigos de correção de erros, construindo novas muralhas defensivas conhecidas como Criptografia Pós-Quântica (PQC).

O término da padronização de FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) e FIPS 205 (SLH-DSA) pelo NIST não é a linha de chegada. É apenas o primeiro passo na épica jornada de migração para PQC que durará décadas. Para engenheiros de software e arquitetos de sistemas, o grande desafio tecnológico será como adaptar de forma otimizada os protocolos de rede e os sistemas para o “aumento no tamanho da chave” e “mudanças nos custos de computação” que esses novos algoritmos trazem.

O conflito entre os computadores quânticos e a criptografia é a área emocionante onde a exploração matemática e a evolução da tecnologia da humanidade se cruzam da forma mais intensa. Esperamos que através deste artigo, você tenha conseguido compreender profundamente as belas teorias matemáticas por trás da PQC e os mecanismos surpreendentes de cada algoritmo que moldará o futuro da cibersegurança.

Referências:

Programa de Padronização de Criptografia Pós-Quântica do NIST
FIPS 203: Padrão para Mecanismo de Encapsulamento de Chaves Baseado em Módulo de Reticulado
FIPS 204: Padrão para Assinaturas Digitais Baseado em Módulo de Reticulado
FIPS 205: Padrão para Assinaturas Digitais Stateless Baseadas em Hash