RSA on kenji.blog

Computadores Quânticos Realmente Destruirão a Criptografia RSA? ~O Algoritmo de Shor e o Estado Atual~

Sat, 05 Sep 2026 22:09:21 +0900

Introdução: A Interseção entre Criptografia e Computadores Quânticos

Na sociedade da internet moderna, a base para proteger o segredo das comunicações é a “criptografia de chave pública”. Um dos mais representativos é a “Criptografia RSA”, desenvolvida em 1977 por Ron Rivest, Adi Shamir e Leonard Adleman. Desde pagamentos de compras online que usamos diariamente, navegação em sites (HTTPS), até envio e recebimento de e-mails, a criptografia RSA funciona como o coração da infraestrutura da internet.

No entanto, com o surgimento dos “computadores quânticos”, foi apontado que essa segurança pode ser subvertida desde a base. Na mídia, às vezes vemos manchetes sensacionalistas como “Se um computador quântico for concluído, senhas e criptografias em todo o mundo serão decifradas em segundos”. Mas será que isso é verdade?

Neste artigo, aprofundaremos como funcionam o GNFS (General Number Field Sieve), um método clássico de descriptografia, e a versão definitiva dos algoritmos de descriptografia usando computadores quânticos, o “Algoritmo de Shor (Shor’s Algorithm)”. Explicaremos de forma fácil conceitos avançados, como a transformação quântica de Fourier e a descoberta de períodos, e examinaremos em detalhes o estado atual do hardware quântico na era NISQ (Noisy Intermediate-Scale Quantum) e os obstáculos reais necessários para quebrar a RSA-2048.

O Núcleo da Criptografia RSA: A Dificuldade da Fatoração em Números Primos

A segurança da criptografia RSA depende de uma assimetria extremamente simples na matemática. Trata-se do fato de que “é fácil multiplicar dois números primos gigantes, mas é extremamente difícil encontrar (fatorar em números primos) os dois números primos originais a partir do resultado dessa multiplicação (número composto)”.

Por exemplo, suponha que existam dois números primos, $ p = 61 $ e $ q = 53 $. Calcular esta multiplicação $ N = p \times q = 3233 $ é instantâneo. No entanto, se receber apenas o número “3233” e tiver que resolver “de quais números primos essa é a multiplicação?”, a quantidade de cálculos explode à medida que o número se torna maior.

No RSA-2048, que é a norma atual, o comprimento da chave é de 2048 bits, ou seja, é usado um número composto gigante $ N $ que chega a cerca de 617 dígitos em decimal. Se esse $ N $ puder ser fatorado em números primos, a criptografia será essencialmente decifrada.

O Desafio dos Computadores Clássicos: GNFS (General Number Field Sieve)

Para resolver o problema da fatoração em números primos, matemáticos e criptógrafos desenvolveram vários algoritmos ao longo dos anos. Entre eles, o que atualmente é considerado o mais rápido em computadores clássicos é o GNFS: General Number Field Sieve.

O GNFS é um método que expande e analisa os cálculos no anel de inteiros para um corpo algébrico (Number Field) mais abstrato, a fim de fatorar o número gigante $ N $. O fluxo geral é o seguinte.

Seleção de Polinômio : Encontrar um polinômio $ f(x) $ com grau e coeficientes apropriados, que tenha $ N $ como raiz.
Coleta de Dados (Peneiramento) : No corpo dos números racionais e no corpo algébrico, procuramos em grande quantidade por pares de números que podem ser decompostos em números primos pequenos (números suaves, Smooth numbers). Esse processo é chamado de “peneiramento” e é a parte que leva mais tempo.
Geração e Redução de Matriz : Com base nas relações coletadas, uma enorme matriz esparsa (uma matriz em que a maioria dos componentes é zero) é gerada e resolvida usando métodos de álgebra linear (como o método de Block Lanczos).
Cálculo da Raiz Quadrada : Finalmente, calcula-se a raiz quadrada no corpo algébrico para derivar os fatores (fatores primos) de $ N $.

A complexidade computacional do GNFS é avaliada não assintoticamente como $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $. Isso é chamado de complexidade de tempo “Sub-exponencial” (Sub-exponential). Embora seja mais rápido que o tempo exponencial, é muito mais lento que o tempo polinomial (Polynomial time).

De fato, em 2020, uma equipe de pesquisa internacional obteve sucesso em fatorar a RSA-250 (829 bits, número composto de 250 dígitos) usando o GNFS. Esse cálculo consumiu um tempo computacional enorme, equivalente a cerca de 2700 CPU-core anos, reunindo recursos de computação de todo o mundo. No entanto, quando isso chega a 2048 bits, é mencionado que a quantidade de cálculo necessária explodiria para trilhões de vezes a idade do universo, tornando impossível descriptografar em um tempo realista com métodos clássicos, não importa quantos supercomputadores atuais funcionem em paralelo.

O Trunfo do Computador Quântico: Algoritmo de Shor

Aqui é onde entra o “Algoritmo de Shor”, publicado por Peter Shor em 1994. Esse algoritmo foi revolucionário por permitir que o problema de fatoração em números primos fosse resolvido no computador quântico em tempo polinomial ( $ O((\log N)^3) $ ). A diferença entre tempo sub-exponencial e polinomial é decisiva e significa, na teoria, que a criptografia RSA será completamente destruída se um computador quântico for usado.

Fluxo Geral do Algoritmo de Shor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[Inserir o número N que se deseja fatorar] --> B[Selecionar um número inteiro aleatório a]
 B --> C{Máximo divisor comum<br>entre a e N}
 C -->|Maior que 1| D[Por sorte, um fator primo foi encontrado!]
 C -->|1 Primos entre si| E[Vez do computador quântico]
 E --> F[Encontrar o período r da<br>função f_x = a^x mod N por Transformação Quântica de Fourier]
 F --> G{O período r é par e<br>a^r/2 ≢ -1 mod N}
 G -->|Sim| H[Calcular o máximo divisor comum gcd_a^r/2 ± 1, N]
 H --> I((Fatoração bem sucedida!))
 G -->|Não| B

O algoritmo de Shor não resolve o problema da fatoração em números primos diretamente, mas usa teoremas da teoria dos números para convertê-lo em outro problema chamado “Problema de Descoberta de Período” (Period Finding Problem) e, em seguida, resolve isso rapidamente aproveitando as características do computador quântico.

Passo 1: Redução da Fatoração ao Problema de Descoberta de Período (Processamento Clássico)

O primeiro passo do algoritmo é feito em um computador clássico. Para o número $ N $ que se deseja fatorar, escolhe-se um número inteiro aleatório $ a $ ( $ 1 < a < N $ ) que seja co-primo (com o máximo divisor comum igual a 1) com $ N $. Se por acaso o máximo divisor comum não for 1, o divisor comum encontrado nesse momento já é um fator de $ N $, e a fatoração está concluída, mas a probabilidade é extremamente baixa.

Em seguida, considere a sequência das seguintes equações modulares: $ f(x) = a^x \pmod N $

Substituindo $ x = 1, 2, 3, \dots $ nesta função $ f(x) $, os valores parecem aleatórios, mas como são calculados em um limite finito, eles sempre voltarão ao valor original em algum ponto, repetindo a mesma sequência de números. Este ciclo de repetição é chamado de período $ r $. Ou seja, O problema de encontrar o menor número inteiro positivo $ r $ tal que $ a^r \equiv 1 \pmod N $, este é o “Problema de Descoberta de Período”.

Se este período $ r $ for encontrado, e $ r $ for um número par, então $ a^r - 1 \equiv 0 \pmod N $, e usando a fórmula de fatoração, pode ser transformado em $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $. A partir daqui, ao calcular o máximo divisor comum entre $ N $ e $ a^{r/2} \pm 1 $ usando o algoritmo de Euclides, um fator de $ N $ pode ser obtido com uma probabilidade extremamente alta.

Para encontrar o período $ r $ em um computador clássico, no final, etapas exponenciais são necessárias e isso não pode ser acelerado. No entanto, com um computador quântico, este período $ r $ pode ser encontrado em um instante (tempo polinomial).

Passo 2: Preparação e Superposição do Estado Quântico

A partir daqui é a vez do computador quântico. Os computadores quânticos usam “qubits”, que podem ter o estado “0” e “1” simultaneamente. No algoritmo de Shor, são preparados dois registradores: o primeiro para armazenar a entrada e o segundo para os resultados do cálculo.

Primeiro, uma operação de porta quântica chamada porta de Hadamard (Hadamard gate) é aplicada a todos os qubits do primeiro registrador. Isso coloca o primeiro registrador em um estado de superposição uniforme de todos os valores concebíveis de $ x $ (de $ 0 $ a $ 2^n-1 $. $ n $ é um número de bits suficientemente grande).

Em outras palavras, dentro do computador quântico, é criado um estado em que incontáveis valores de entrada como $ x=0, 1, 2, 3, \dots $ existem em paralelo ao mesmo tempo.

Passo 3: Exponenciação Modular Quântica (Quantum Modular Exponentiation)

Em seguida, o estado de superposição do primeiro registrador é usado como entrada para calcular $ f(x) = a^x \pmod N $, e o resultado é armazenado no segundo registrador. Como este cálculo é executado como uma transformação unitária no circuito quântico, o cálculo de $ f(x) $ para todos os $ x $ é feito de forma “paralela (paralelismo quântico)” enquanto a superposição é mantida.

O espaço do sistema quântico inteiro neste ponto, torna-se uma enorme superposição de estados $ |x, a^x \bmod N\rangle $.

No entanto, se você simplesmente medir (observar) o segundo registrador aqui, um valor aleatório de $ a^x \bmod N $ será probabilisticamente selecionado, e em conjunto com isso, o $ x $ do primeiro registrador também será determinado. Isso não é diferente de calcular uma vez em um computador clássico, e você não conseguirá encontrar o período $ r $.

Nas regras da mecânica quântica, você não pode observar o conteúdo de um estado de superposição diretamente. Então, como extrair a informação global chamada “período”?

Passo 4: Transformada Quântica de Fourier (QFT: Quantum Fourier Transform)

O verdadeiro valor do algoritmo de Shor, que supera esse obstáculo, é a aplicação da Transformada Quântica de Fourier (QFT) ao primeiro registrador.

Antes de medir, analisamos a natureza da onda da função $ f(x) $. Vamos supor que o segundo registrador foi observado. Suponha que um valor $ y $ foi obtido. Então, o estado do primeiro registrador encolhe para “a superposição de todos os $ x $ tais que $ a^x \pmod N = y $”. O valor deste $ x $ estará em um estado discreto com intervalos do período $ r $ (uma espécie de distribuição de amplitude de probabilidade em forma de pente), como $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $.

Aplicamos a Transformada Quântica de Fourier (QFT) a este estado. Assim como a Transformada Discreta de Fourier clássica converte sinais no domínio do tempo para o domínio da frequência, a QFT faz com que as amplitudes de probabilidade do estado quântico interfiram.

Quando a QFT é aplicada, devido ao efeito de interferência quântica, as probabilidades de respostas incorretas que não ressoam com o período $ r $ (fases não alinhadas) se cancelam mutuamente chegando perto de zero (interferência destrutiva), e apenas as probabilidades da resposta correta contendo a informação do período $ r $ são amplificadas (interferência construtiva).

Passo 5: Medição e Fração Contínua (Pós-processamento Clássico)

Após aplicar a QFT, se você medir o primeiro registrador, com uma probabilidade muito alta, um número inteiro $ c $ próximo à forma $ c \approx \frac{j \cdot 2^n}{r} $ será obtido ( $ j $ é um inteiro desconhecido, e $ 2^n $ é o tamanho do registrador).

Trazendo o resultado desta medição $ c $ de volta para um computador clássico, criamos uma fração $ \frac{c}{2^n} \approx \frac{j}{r} $. Em seguida, usando o método matemático da “Expansão de Fração Contínua” (Continued fraction expansion) para calcular valores aproximados, podemos descobrir o período $ r $, que é o denominador.

Uma vez conhecido o $ r $, o resto é calcular os fatores de $ N $ usando a fórmula do Passo 1, e a criptografia RSA é completamente quebrada.

A Força e os Desafios do Computador Quântico Atual (NISQ)

Embora teoricamente o algoritmo de Shor seja perfeito, se perguntado “A criptografia RSA será quebrada amanhã?”, a resposta é claramente “Não”. O motivo está nas limitações da tecnologia de hardware dos computadores quânticos atuais.

A Era NISQ (Noisy Intermediate-Scale Quantum)

A era em que nos encontramos atualmente é chamada de “NISQ”. Dispositivos NISQ possuem dezenas a centenas de qubits físicos, mas são extremamente vulneráveis ao ruído.

Os qubits são facilmente afetados pelo ambiente externo, como calor e ondas eletromagnéticas, e ocorrem frequentemente “decoerência” (perda de emaranhamento quântico), onde o estado quântico se quebra, e “erros de porta” durante as operações. Quando se tenta executar um circuito quântico muito profundo (com um número enorme de passos operacionais) como o algoritmo de Shor, os erros se acumulam durante o cálculo e a saída final torna-se puro ruído sem significado.

Qubit Físico e Qubit Lógico

O que é essencial para resolver este problema de erros é a “Correção de Erros Quânticos” (Quantum Error Correction). Embora códigos de correção de erros também sejam usados em computadores clássicos, devido ao “teorema da não-clonagem”, que proíbe a cópia de estados quânticos, a correção de erros quânticos é extremamente complexa.

Na correção de erros quânticos, utilizando tecnologias como “Código de Superfície” (Surface Code), muitos “qubits físicos” ruidosos são combinados para criar um “qubit lógico” ideal e livre de erros.

Assumindo a taxa de erro atual, estima-se que cerca de 1.000 a 10.000 qubits físicos seriam necessários para criar um único qubit lógico. Isso é chamado de “overhead da correção de erros”.

Que Recursos são Necessários para Quebrar a RSA-2048?

Então, para realmente descriptografar a RSA-2048, quantos recursos seriam necessários para rodar o algoritmo de Shor?

Em uma estimativa inovadora de recursos em um artigo de 2021 de Craig Gidney (Google) e Martin Ekerå, foi afirmado que se um algoritmo de Shor otimizado fosse usado, e correção de erros com código de superfície fosse realizada, os seguintes recursos seriam necessários:

Número de qubits lógicos : Aproximadamente 4.096
Número de qubits físicos : Aproximadamente 20 milhões (assumindo uma taxa de erro de $10^{-3}$)
Tempo de cálculo : Aproximadamente 8 horas (milhões a bilhões de operações físicas de porta necessárias)

Em contraste com isso, qual é o nível que o hardware quântico atual alcançou? O processador quântico supercondutor “Condor”, anunciado pela IBM no final de 2023, possui 1.121 qubits. Além disso, pesquisas inovadoras sobre a geração de qubits lógicos têm aparecido (como a geração de 48 qubits lógicos usando computadores quânticos de átomos neutros pela Universidade de Harvard, QuEra, etc.), mas ainda não chegamos no estágio de conseguir executar “cálculos perfeitos e sem ruído” continuamente por longos períodos.

Passar de alguns milhares de qubits físicos para 20 milhões de qubits físicos práticos (que estão interconectados, operam de forma estável em temperaturas ultrabaixas e podem processar sinais de controle em velocidades ultrarrápidas) apresenta uma enorme barreira na engenharia (problemas de fiação, limites da capacidade de refrigeração e inchaço da eletrônica de controle). Muitos especialistas preveem que levará pelo menos 10 a 30 anos, ou mais, até que um “Computador Quântico Tolerante a Falhas” (FTQC - Fault-Tolerant Quantum Computer), capaz de quebrar a RSA-2048, se torne uma realidade.

A Ameaça Silenciosa de “Store Now, Decrypt Later” e o Amanhecer da PQC

Concluir que “estamos seguros porque ainda levará mais de 10 anos” é precipitado. Atualmente, existem dados que devem ser mantidos em segredo por décadas no futuro, como segredos de estado, dados médicos e projetos de infraestrutura de longo prazo.

A preocupação aqui é o método de ataque chamado “Store Now, Decrypt Later” (Armazene Agora, Descriptografe Depois). Nações ou organizações mal-intencionadas interceptam todos os dados de comunicação atualmente criptografados usando RSA ou ECC (Criptografia de Curva Elíptica) e os guardam no armazenamento. E então, no momento em que um poderoso computador quântico for concluído em 10 ou 20 anos, eles usarão o algoritmo de Shor para descriptografar todos os dados do passado e expor os segredos.

Para combater essa ameaça de tempo, liderado pelo NIST (Instituto Nacional de Padrões e Tecnologia dos EUA), o processo de padronização da “Criptografia Pós-Quântica” (PQC: Post-Quantum Cryptography) tem sido acelerado em ritmo acelerado.

A PQC é um novo algoritmo de criptografia baseado em problemas matemáticos que são difíceis de descriptografar mesmo usando um computador quântico (ou seja, o algoritmo de Shor não pode ser aplicado). Como principais abordagens, temos:

Criptografia baseada em reticulados (Lattice-based cryptography) : Baseado em problemas como LWE (Learning with Errors). O método dominante na padronização do NIST (Kyber, Dilithium, etc.).
Criptografia baseada em códigos (Code-based cryptography) : Depende da dificuldade do problema de decodificação de códigos corretores de erro.
Criptografia polinomial multivariável (Multivariate cryptography) : Depende da dificuldade de resolver equações quadráticas simultâneas multivariáveis.
Assinaturas baseadas em hash (Hash-based signatures) : Assinaturas digitais que dependem exclusivamente da segurança das funções de hash.

Testes de implementação e implementações híbridas da PQC já foram iniciados nos principais softwares e plataformas, como o Google Chrome e o iMessage da Apple.

Conclusão

Os computadores quânticos estão passando de histórias de ficção científica para desafios reais de engenharia. O algoritmo de Shor é uma grande conquista intelectual da humanidade que mescla a matemática e a mecânica quântica, mas, ao mesmo tempo, guarda um “poder destrutivo” para sacudir as bases da nossa sociedade digital.

Isso não significa que a criptografia RSA se tornará inutilizável a partir de amanhã. No entanto, considerando a evolução da tecnologia quântica e o risco do “Store Now, Decrypt Later”, a grande migração que ficará na história da criptografia - a transição para a PQC - já começou. Agora estamos testemunhando a linha de frente de uma mudança de paradigma na segurança da informação.

【Análise Completa】Entendendo e Implementando o Mais Forte Algoritmo de Quebra de Criptografia 'GNFS' em C++

Sat, 05 Sep 2026 13:04:59 +0900

【Análise Completa】Entendendo e Implementando o Mais Forte Algoritmo de Quebra de Criptografia “GNFS” em C++

A criptografia RSA, que sustenta a internet moderna, baseia-se na crença matemática de que “é virtualmente impossível para os computadores atuais fatorar números compostos gigantescos”.

No entanto, a humanidade nunca desistiu. Atualmente, existe o mais forte e avançado algoritmo da humanidade para a fatoração de grandes números primos em computadores clássicos (não quânticos). É o “General Number Field Sieve (GNFS - Crivo Geral do Corpo de Números)”.

Neste artigo, publicaremos o código de implementação completo que modela estritamente a lógica de computação mais avançada do GNFS em C++ (usando os inteiros de multiprecisão boost::multiprecision da biblioteca Boost), e explicaremos minuciosamente as profundezas da “teoria algébrica dos números” por trás dele.

Por favor, aproveite os mistérios da matemática e a força bruta da ciência da computação que os domina, juntamente com o código-fonte.

1. Framework de Lógica GNFS Avançado (Código Fonte Completo)

Primeiro, apresentaremos o quadro geral da implementação C++ do GNFS que explicaremos desta vez. Embora o GNFS real (como o CADO-NFS) seja um enorme sistema distribuído que abrange centenas de milhares de linhas, este código extrai e modela as “5 pipelines (fases) essenciais” que compõem o GNFS no design de classes, na configuração mínima, sem perder seu significado matemático.

 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
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Usando inteiros de multiprecisão do Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] Framework Lógico Avançado do General Number Field Sieve (Crivo Geral do Corpo de Números)
//
// Este código modela estritamente os 5 pipelines avançados do GNFS usados
// no CADO-NFS etc., como o design de classes C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Fase 1: Polynomial Selection (Seleção Polinomial - Algoritmo de KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinômio do lado algébrico f(x)
 std::vector<cpp_int> g; // Polinômio do lado racional g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Geração do polinômio inicial baseado na expansão base-m (Na realidade, usa a redução de base reticulada LLL, que é mais avançada)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Seleção Polinomial (Grau " << degree << ") iniciando..." << std::endl;
 // Expansão base-m simples (grau d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Aproximação simples de m (Aproximação sem usar as funções do Boost)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Fase 1] Concluída." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Crivo de Reticulado)
// ============================================================================
// Nos últimos anos, em vez de Line Sieve (Crivo de Linha), o Special-q Lattice Sieving (Crivo de Reticulado q Especial)
// de Franke-Kleinjung e outros é o padrão de fato.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Fase 2] Gerando Bases de Fator (Limite Racional: " << rational_bound << ", Limite Algébrico: " << algebraic_bound << ")" << std::endl;
 // (Omitido) Na realidade, ele gera números primos e restringe usando o símbolo de Legendre etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving ativo..." << std::endl;
 std::vector<Relation> relations;
 // Implementação simulada: O crivo de reticulado real varre centenas de GB de espaço de memória em unidades de bloco.
 // Mapeia o par (a, b) para a grade para cada primo especial q (a = i*q + j*...) e
 // executa um sieve (crivo) que maximiza a eficiência do cache ao limite.

 // Adicionando uma relação simulada para fins de demonstração
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Fase 2] Encontradas " << relations.size() << " relações." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Expurgo de Singularidades e Fusão de Cliques)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Filtrando Relações..." << std::endl;
 // 1. Singleton removal (Remoção de relações com números primos que aparecem apenas uma vez)
 // 2. Clique merging (Fusão de relações para tornar uma matriz esparsa em uma matriz densa)
 // Na verdade, comprime matrizes de centenas de milhões de linhas em alguns milhões usando algoritmos como Union-Find.
 std::cout << "[Fase 3] Tamanho da matriz reduzido idealmente." << std::endl;
 }
};

// ============================================================================
// Fase 4: Linear Algebra over GF(2) (Método Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // Em ambientes de supercomputadores recentes, o Método Block Wiedemann (Implementação de Coppersmith)
 // é usado como a tecnologia mais avançada porque é mais adequado para computação distribuída
 // do que o Método Block Lanczos.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritmo de Block Wiedemann sobre GF(2) iniciando..." << std::endl;
 // Repete a operação de produto da matriz esparsa e vetor,
 // e encontra vários vetores de solução (kernel) em que M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Lista de dependências
 // Dados simulados
 dependencies.push_back({0});

 std::cout << "[Fase 4] Encontradas " << dependencies.size() << " dependências lineares (quadrados perfeitos)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Algebraic Square Root (Raiz Quadrada Algébrica)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Fase 5] Computação da Raiz Quadrada Algébrica..." << std::endl;

 // 1. Cálculo da raiz quadrada V no lado racional (Operação de inteiro simples)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Cálculo da raiz quadrada gamma no lado algébrico (Método de Montgomery, etc.)
 // Obtém o elemento gamma do enorme corpo algébrico O_K e o mapeia para o mundo real com o homomorfismo phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Pressupõe que sequências de Caracteres Quadráticos (Quadratic Characters)
 // foram adicionadas nas Fases 2 e 4 para evitar a obstrução (Obstruction) do grupo de classes de ideais e o grupo de unidades.

 std::cout << " -> Mapa de homomorfismo phi aplicado." << std::endl;
 std::cout << "[Fase 5] Calculando GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCESSO] Fator não trivial encontrado: " << factor << std::endl;
 std::cout << " Outro fator: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FALHA] Solução trivial. Tentando próxima dependência..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline (Pipeline de Execução Principal)
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Motor do General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // O grande número composto N que queremos fatorar, como RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Grau do polinômio (Normalmente, de 5º a 6º grau é selecionado para números com mais de 130 dígitos)
 int degree = 6;

 // Inicializando pipelines
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Na realidade, os limites são dezenas de milhões a centenas de milhões
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Seleção Polinomial
 poly_select.select(N);

 // 2. Processamento do Sieve (Crivo)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtragem (Compressão de Matriz)
 filter.reduce_matrix(relations);

 // 4. Álgebra Linear (Busca de espaço nulo (Nullspace) em GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Cálculo da Raiz Quadrada Algébrica e GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[Sistema] Pipeline GNFS Avançado concluído em " << elapsed.count() << " segundos." << std::endl;

 return 0;
}

Então, como este código quebra os muros da criptografia? Explicaremos detalhadamente a matemática avançada e os algoritmos precisos para cada uma das 5 fases.

2. Objetivo Final do GNFS: $X^2 \equiv Y^2 \pmod N$

O objetivo da maioria dos algoritmos modernos de fatoração de grandes números, não apenas o GNFS, é encontrar um par não trivial $(X, Y)$ que satisfaça a seguinte congruência:

$$X^2 \equiv Y^2 \pmod N$$

Esta fórmula significa que “o resto de $X^2$ e $Y^2$ quando divididos por $N$ é o mesmo”. Se reescrevermos isso, obtemos: $X^2 - Y^2 \equiv 0 \pmod N$ Em outras palavras, $(X-Y)(X+Y)$ é um múltiplo de $N$.

Se $X \not\equiv \pm Y \pmod N$ (uma solução não trivial), então haverá um “divisor comum maior que 1 e menor que $N$” entre $(X-Y)$ e $N$. Aqui, usando o algoritmo de Euclides para calcular $\gcd(X-Y, N)$ , os fatores primos de $N$ podem ser encontrados muito facilmente.

No entanto, encontrar esses $X$ e $Y$ é como procurar uma agulha em um palheiro. Portanto, o GNFS tem uma abordagem genial: criar dois mundos - “o mundo dos inteiros reais” e “o mundo dos corpos algébricos dos polinômios” - e distribuir a computação.

3. Fase 1: Seleção Polinomial (Polynomial Selection)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Cálculo de m = N^(1/d) e expansão base-m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

O primeiro passo do GNFS é criar os “polinômios mágicos” para fazer a ponte entre os dois mundos. Para um número muito grande $N$, escolhemos um número inteiro $m$. Normalmente o escolhemos de modo que $m \approx N^{1/d}$ (no código, assumimos um polinômio de grau $d=6$).

Em seguida, o $N$ é expandido na base $m$, e esses coeficientes são usados para construir um polinômio $f(x)$.

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Este polinômio $f(x)$ tem uma propriedade muito importante: “Se substituirmos $x$ por $m$, o resultado será exatamente $N$ ($f(m) = N$)” . Em outras palavras, $f(m) \equiv 0 \pmod N$. O polinômio do lado racional é definido como $g(x) = x - m$.

Com isso, “o mundo do corpo algébrico $\mathbb{Z}[\alpha]$” governado pela raiz $\alpha$ de $f(x)=0$, e “o mundo dos números racionais (inteiros) $\mathbb{Z}$” estão fortemente ligados pelo “mapa de homomorfismo de anel” $x \to m$.

No CADO-NFS mais avançado, usa-se o algoritmo de KleinJung ou o algoritmo de redução de base de reticulado LLL para passar meses procurando o “polinômio mais conveniente $f(x)$” cujos coeficientes não são extremamente grandes e em que os números primos são mais propensos a aparecer (lisos) nas etapas subsequentes.

4. Fase 2: Crivo de Reticulado $q$ Especial (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Mapeia os pares (a, b) para reticulados baseados em cada número primo especial q
 // e executa o sieve (crivo) de forma muito eficiente usando a memória cache.
 // ...
 }
};

Com os dois mundos prontos, o próximo passo é procurar “números lisos” (números compostos apenas por números primos pequenos) em ambos os mundos. Geramos inúmeros pares de inteiros $(a, b)$ e calculamos os dois valores a seguir:

Valor racional: $a - bm$
Norma algébrica: $b^d f(a/b)$

O objetivo do GNFS é coletar de dezenas a centenas de milhões desses “pares (Relação) em que os valores dos lados racional e algébrico podem ser completamente decompostos em fatores primos pequenos” .

No GNFS inicial, era usado o “Line Sieve” (Crivo de Linha), no qual $(a, b)$ são alinhados em um plano $xy$ e sequencialmente divididos por números primos da borda. Mas esse método apresentava a fraqueza de ser muito lento por acessar memórias espalhadas causando muitos erros de cache.

Por isso, na vanguarda, utiliza-se a técnica “Crivo de Reticulado $q$ Especial (Special-q Lattice Sieve)”. Isso fixa um número primo consideravelmente grande $q$ e visa calcular apenas “os pares $(a, b)$ nos quais o valor algébrico é sempre divisível por $q$”. Os $(a, b)$ que satisfazem essa condição formam uma “Lattice” (Reticulado) no plano. Então, a largura do salto dos endereços de memória a calcular torna-se constante, o que se adapta perfeitamente aos caches L1/L2 da CPU. Graças a essa introdução do Crivo de Reticulado, a velocidade de computação do GNFS aumentou drasticamente.

5. Fase 3: Filtragem (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (Remoção de relações com números primos que aparecem apenas uma vez)
 // 2. Clique merging (Fusão de relações para tornar uma matriz esparsa em uma matriz densa)
 }
};

Na Fase 2, as relações coletadas ao longo de meses por computadores em todo o mundo somam centenas de milhões. No entanto, se inserirmos isso como está no próximo passo de “resolução do sistema de equações” (cálculo de matriz), a memória dos supercomputadores falhará.

Portanto, ocorre um processo de supercompressão de matriz chamado Filtering (Filtragem) .

Singleton removal (Expurgo de singularidades): Suponha que um número primo enorme $p$ apareça “apenas uma vez” entre as centenas de milhões de relações. Nosso objetivo é “tornar o expoente de todos os números primos um número par (múltiplo de 2)”; os números primos que aparecem apenas uma vez nunca podem ser tornados pares. Portanto, a relação que inclui aquele número primo é imediatamente removida (expurgada) como “lixo sem utilidade”. Quando isso acontece em cadeia, os dados que antes eram de centenas de milhões de linhas são sistematicamente reduzidos.
Clique merging (Fusão de cliques): Ao cruzar e somar relações que compartilham um número primo em comum, diminuímos o número de linhas e, simultaneamente, transformamos a matriz esparsa (cheia de zeros) numa matriz mais densa (método semelhante à busca de cliques na teoria dos grafos).

Com essas otimizações, a gigantesca matriz esparsa é comprimida a um tamanho possível de calcular.

6. Fase 4: Álgebra Linear em GF(2) (Método Block Wiedemann)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Repete a operação de produto da matriz esparsa e vetor,
 // e encontra vários vetores de solução (kernel) em que M * x = 0 mod 2.
 }
};

Finalmente, a essência do quebra-cabeça. Multiplicamos as relações recolhidas buscando as “combinações que tornam o expoente de todos os fatores primos par” .

Em termos matemáticos, isso equivale a encontrar um vetor de solução $x$ (espaço nulo / kernel) onde, utilizando uma matriz gigante $M$ com elementos sendo o expoente de cada número primo no “par ou ímpar (ou seja, 0 ou 1)” e um vetor $x$ que diz quais relações usar, temos: $M \cdot x \equiv 0 \pmod 2$

É necessário resolver equações simultâneas de uma matriz de milhões de linhas por milhões de colunas. O uso tradicional do método de eliminação de Gauss levaria $O(N^3)$ em tempo de cálculo e não acabaria antes do fim do universo.

Por esse motivo, as implementações de ponta utilizam o “Método de Block Wiedemann”. Esse método aproveita que a matriz $M$ é “extremamente esparsa (quase totalmente zeros)” para obter a solução multiplicando iterativamente matrizes por vetores. É um tipo de método do subespaço de Krylov. Diferente do antigo Block Lanczos, o método Block Wiedemann pode particionar totalmente o processo computacional entre vários clusters, tornando seu uso extremamente valioso em clusters modernos e em sistemas paralelos de computação distribuída (cloud e supercomputadores).

7. Fase 5: Raiz Quadrada Algébrica (Algebraic Square Root) e o Colapso Criptográfico

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Cálculo da raiz quadrada V no lado racional
 cpp_int V = 1;

 // 2. Cálculo da raiz quadrada gamma no lado algébrico
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Pelo cálculo matricial na Fase 4, adquirimos o “conjunto de relações $S$ cujos expoentes de todos os fatores primos formam um expoente par quando multiplicados juntos”. Isto possibilita construir o “quadrado perfeito” em ambos os mundos: o lado racional e o lado algébrico.

No lado racional, o cálculo é uma simples multiplicação de números inteiros, por isso é simples calcular sua raiz quadrada $V$.

$$V^2 = \prod_{S} (a - bm)$$

Porém, o real pesadelo encontra-se no “lado algébrico”. No mundo do corpo algébrico $\mathbb{Z}[\alpha]$, dado que a unicidade da fatoração em primos não é mantida, realizávamos cálculos usando ideais. A garantia dada pelo cálculo matricial era “apenas que seria o quadrado de um ideal, e não garantia que seria o quadrado de um elemento ($\gamma^2$)”.

Deste modo, surge uma imensa barreira provinda da teoria algébrica dos números, as chamadas “Obstrução do grupo de classes de ideais” e a “Obstrução do grupo das unidades”. No GNFS, usamos a mágica do “Caracter Quadrático (Quadratic Characters)” para quebrar essa parede. Inserimos sorrateiramente várias colunas de símbolos residuais quadráticos (símbolos de Legendre) na matriz da Fase 4 para uma dezena de números ideais primos, de forma que a chance de as obstruções sumirem aumente brutalmente, e que assim, garantam finalmente “o autêntico quadrado de um elemento $\gamma^2$”.

Em seguida, calcula-se o $\gamma$ (raiz quadrada algébrica) usando algoritmos complexos, como o método de Montgomery.

Por último, fazemos a raiz algébrica $\gamma$ sofrer um “warp” para o mundo verdadeiro usando o mapa de homomorfismo de anéis $\phi$ (substituindo $x$ por $m$) para encontrar $Y$. Quando colocamos o $V$ do lado racional para ser o $X$, a equação absoluta cobiçada está finalmente perfeita.

$$X^2 \equiv Y^2 \pmod N$$

O restante é somente resolver o $\gcd(X-Y, N)$. Em milissegundos o processo acaba e exibe o fator não trivial impresso na tela. Nesse instante, a criptografia impenetrável RSA é inteiramente derrubada.

Conclusão

O GNFS não é só uma técnica de programação. Trata-se de forçar as “profundezas da matemática pura” como álgebra abstrata, teoria dos anéis e os grupos de classe ideal através do poder colossal da “engenharia extrema”, como arquitetura de computadores distribuída em supercomputadores, além de otimizações de cache; um pilar glorioso da mente humana.

Por trás de transações por cartão de crédito ou simples chats do dia-a-dia, encontra-se esta astronômica barreira defensiva construída através do poderio e batalha da matemática.

Espero que compreendam que, na retaguarda dos fortes algoritmos criptográficos, existe um “romance dos computadores com a matemática” oculto neste simples framework em C++.

A Verdadeira Estrutura Matemática do Crivo Geral dos Corpos de Números (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

A Verdadeira Estrutura Matemática do Crivo Geral dos Corpos de Números (GNFS)

O objetivo final do GNFS é encontrar $X, Y$ tais que $X^2 \equiv Y^2 \pmod N$. Para alcançar isso, os matemáticos construíram uma ponte entre o “mundo dos inteiros reais” e o “mundo dos corpos algébricos” . Essa ponte é exatamente o “homomorfismo”.

Fase 1: Conectando os mundos com “Homomorfismo”

1. Seleção do polinômio e definição das raízes

Para um número composto gigante $N$, escolhemos um inteiro $m$ e um polinômio $f(x)$ tais que $f(m) \equiv 0 \pmod N$. (Exemplo: Expandimos $N$ na base $m$ e criamos $f(x)$ a partir de seus coeficientes. Neste momento, assumimos que $f(x)$ é irredutível sobre o corpo dos números racionais $\mathbb{Q}$ (não pode ser mais fatorado)).

Em seguida, definimos uma das “raízes complexas” da equação $f(x) = 0$ como $\alpha$. Naturalmente, $f(\alpha) = 0$. $\alpha$ não é um número inteiro, mas um número complexo envolvendo raízes e números imaginários (um número algébrico).

2. Construção de Anéis (Rings) e Homomorfismo

Aqui, preparamos dois “anéis” matemáticos (mundos onde adição e multiplicação são definidas).

Mundo A: $\mathbb{Z}[\alpha]$ (O anel dos inteiros algébricos contendo $\alpha$) Um mundo de números expressos na forma $a + b\alpha + c\alpha^2 + \dots$.
Mundo B: $\mathbb{Z}/N\mathbb{Z}$ (O anel dos restos módulo $N$) Um mundo de congruências composto apenas por inteiros de $0$ a $N-1$.

Aqui, definimos um mapeamento $\phi$ do Mundo A para o Mundo B da seguinte forma. $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Este mapeamento $\phi$ é uma operação mágica que substitui exatamente a variável $\alpha$ do Mundo A pelo inteiro $m$ do Mundo B. Este $\phi$ possui uma propriedade extremamente poderosa chamada “Homomorfismo de Anéis (Ring Homomorphism)” . Homomorfismo é a propriedade de “teleportar para outro mundo sem destruir a estrutura da adição e multiplicação” . Em outras palavras, as seguintes equações são válidas:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

O que isso significa? Se pudermos criar o “quadrado ($\gamma^2$)” de algum elemento complexo $\gamma$ no “Mundo A (o mundo de $\alpha$)”, e teleportá-lo para o “Mundo B (mundo dos restos)” usando $\phi$, a forma quadrada $\phi(\gamma)^2$ é perfeitamente preservada .

Fase 2: O Colapso da Fatoração em Números Primos e o Nascimento dos “Ideais”

No Mundo A ($\mathbb{Z}[\alpha]$), queremos reunir muitos elementos adequados $(a - b\alpha)$ e multiplicá-los para criar um “quadrado perfeito (elemento quadrado)”. Normalmente, faríamos a “fatoração em números primos” de cada $(a - b\alpha)$ coletado e os combinaríamos de forma que os expoentes dos primos fossem todos pares (resolvendo com matrizes) para formar um quadrado.

No entanto, aqui, a parede desesperadora da álgebra se ergue. Em mundos de corpos algébricos como $\mathbb{Z}[\alpha]$, a “unicidade da fatoração em números primos (qualquer número pode ser expresso de forma única como o produto de primos)” ensinada no ensino médio colapsa .

(Exemplo: Em um certo mundo de corpo algébrico, $6 = 2 \times 3$, mas ao mesmo tempo $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, e não sabemos mais quais são os verdadeiros primos)

Se a fatoração não for única, o quebra-cabeça de “contar o número de primos para torná-los pares” (o método do crivo) é, em princípio, impossível de executar.

A Salvação de Kummer e Dedekind: “Ideais”

O que salvou esse colapso foi o conceito de “Ideal (Ideal: número ideal)” criado pelos matemáticos do século 19. Pensando não no elemento em si, mas no “conjunto de múltiplos (ideal)” gerado por esse elemento, a fatoração em números primos tornou-se possível novamente.

No anel de inteiros de um corpo algébrico $\mathcal{O}_K$ (um anel mais completo contendo $\mathbb{Z}[\alpha]$), é provado que mesmo que um elemento não possa ser fatorado unicamente, “um ideal sempre pode ser fatorado unicamente como o produto de ‘Ideais Primos ($\mathfrak{p}$)’” .

Portanto, no GNFS, em vez de fatorar o próprio elemento $(a - b\alpha)$, fatoramos o ideal principal $\langle a - b\alpha \rangle$ gerado por ele em ideais primos .

Fase 3: A Norma (Norm) e os Dois Crivos (Sieves)

Então, como sabemos em quais ideais primos o ideal $\langle a - b\alpha \rangle$ é decomposto? Aqui usamos uma função chamada “Norma (Norm)” . A Norma é uma função que converte elementos complexos de corpos algébricos em “inteiros reais normais $\mathbb{Z}$”.

A norma do elemento $(a - b\alpha)$ é encontrada por um cálculo polinomial simples $b^d f(a/b)$ ($d$ é o grau de $f(x)$).

Por um teorema algébrico, sabemos que “se a norma de um certo ideal puder ser completamente fatorada em pequenos números primos (for suave), então o ideal original também pode ser completamente fatorado em pequenos ideais primos” .

Então, para um grande número de pares de inteiros $(a, b)$, o GNFS calcula os dois seguintes simultaneamente e coleta apenas os pares em que ambos se tornam “números suaves”:

Crivo Racional (Rational Sieve) : $a - bm$ (o valor no mundo real)
Crivo Algébrico (Algebraic Sieve) : $b^d f(a/b)$ (a norma no mundo dos corpos algébricos)

Coletando dezenas de milhões de pares $(a, b)$ em que ambos são suaves, resolvemos os dados de fatoração de ideais primos (quantos ideais primos estão incluídos) como uma matriz gigante (álgebra linear sobre GF(2)) para encontrar um conjunto $S$ de pares tal que “quando multiplicados, os expoentes de todos os ideais primos se tornem pares”.

Fase 4: Os Dois “Obstáculos” e o Grupo de Classes de Ideais

A partir do cálculo da matriz, descobrimos que multiplicar todos os ideais de $(a - b\alpha)$ pertencentes ao conjunto $S$ resulta no quadrado de um certo ideal $I$.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

No entanto, ainda não acabou. A barreira matemática mais profunda e difícil do GNFS está aqui.

O que queremos no final não é o “quadrado de um ideal”, mas o “quadrado de um elemento ($\gamma^2$)” para substituir no mapeamento $\phi$. Só porque se tornou o quadrado de um ideal, não significa necessariamente que o elemento em si é um quadrado. Existem dois fortes obstáculos matemáticos (Obstructions) aqui.

Obstáculo ①: A Barreira do Grupo de Classes de Ideais (Ideal Class Group)

O ideal $I$ nem sempre é um “ideal gerado por um único elemento (ideal principal)”. É impossível extrair um elemento específico $\gamma$ de um ideal que não é principal.

Aqui entra o conceito de “Grupo de Classes de Ideais (Class Group, $Cl_K$)” . O grupo de classes de ideais é um grupo que mede “quantos ideais existem no mundo daquele corpo algébrico que não são principais (o quanto a unicidade da fatoração se quebra)”. Mesmo que $\prod \langle a - b\alpha \rangle$ se torne $I^2$, se $I$ não for o elemento de identidade (ideal principal) no grupo de classes de ideais, ele não pode ser trazido de volta ao quadrado de um elemento.

Obstáculo ②: A Barreira do Grupo de Unidades (Unit Group)

Suponhamos que, por sorte, $I$ fosse o ideal principal $\langle \gamma \rangle$. Então, teríamos $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Você pode pensar, “Ótimo, o elemento também é um quadrado!”, mas isso é um grande erro.

Ideais (conjuntos de múltiplos) sendo iguais não significa que os elementos sejam perfeitamente iguais. Sempre haverá um desvio por uma “Unidade (Unit: um número cujo inverso também é um inteiro. Por exemplo, 1 ou -1)” . Em outras palavras, a verdadeira equação dos elementos se torna assim:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ é um elemento do grupo de unidades $U_K$)

A menos que esta unidade $u$ em si seja o quadrado de algo, o lado esquerdo nunca pode se tornar um “quadrado perfeito de um elemento”.

Fase 5: A Magia de Adleman “Caracteres Quadráticos” (Quadratic Characters)

O obstáculo do grupo de classes de ideais e o obstáculo do grupo de unidades. Como superar esses dois? Aqui entra o brilhante método dos “Caracteres Quadráticos (Quadratic Characters)” , introduzido pelo criptógrafo Leonard Adleman (o “A” do RSA) e outros.

Para determinar “se um certo elemento é um quadrado perfeito no corpo algébrico”, usamos a versão de corpos algébricos do Símbolo de Legendre (resíduo quadratique). Naquela matriz gigante anterior (o quebra-cabeça para tornar pares as contagens de ideais primos), nós furtivamente adicionamos algumas dezenas de condições extras (colunas) dizendo “os caracteres quadráticos para certos ideais primos especiais $\mathfrak{q}$ também devem ser todos $1$ (par)” .

Quando encontramos um conjunto $S$ que satisfaz até mesmo essas condições adicionais através de cálculos de matrizes, teoremas profundos da teoria algébrica dos números garantem que “tanto o obstáculo do grupo de classes de ideais quanto o obstáculo do grupo de unidades desaparecerão naturalmente com uma probabilidade esmagadora” .

Com isso, finalmente obtemos a verdadeira equação.

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Fase Final: A Fusão dos Mundos e o Colapso Criptográfico

Finalmente, todas as peças do quebra-cabeça estão no lugar.

[Elementos no Mundo dos Corpos Algébricos (Mundo A)] $\gamma^2 = \prod (a - b\alpha)$ (Nós usamos um algoritmo de raiz quadrada para encontrar $\gamma$)

[Elementos no Mundo Real (Mundo dos Números Racionais)] $V^2 = \prod (a - bm)$ (Como esta é uma simples multiplicação de inteiros, $V$ é encontrado normalmente)

Agora é hora daquela ponte mágica que construímos no início, o homomorfismo $\phi$ . Nós teleportamos o elemento $\gamma$ do Mundo A para o Mundo B (o mundo dos restos de $N$) usando $\phi$ (o mapeamento onde substituímos $\alpha$ por $m$).

$$Y = \phi(\gamma) \pmod N$$

Por outro lado, levamos o $V$ construído no mundo real diretamente para o mundo dos restos e o chamamos de $X$.

$$X = V \pmod N$$

Devido à propriedade “preservadora de estrutura” do homomorfismo, a relação quadrada que se manteve no Mundo A é perfeitamente preservada no Mundo B (o mundo módulo $N$). Além disso, como os pares originais $(a, b)$ foram feitos em correspondência nas formas $a - b\alpha$ e $a - bm$, estes $X$ e $Y$ colidem no mundo módulo $N$ e produzem a seguinte equação absoluta.

$$X^2 \equiv Y^2 \pmod N$$

Tudo o que resta é rezar para que esses $X$ e $Y$ não sejam soluções triviais ($X \equiv \pm Y$) e calcular $\gcd(X - Y, N)$ .

Se for uma solução não trivial, o algoritmo euclidiano avança em 0.001 segundos, e os números primos secretos $p$ e $q$, que são o coração da criptografia RSA, são impressos na tela de saída.

Este é o quadro completo do “Crivo Geral dos Corpos de Números (GNFS)” , a essência da matemática moderna.

O que é o "General Number Field Sieve (GNFS)", a matemática mais poderosa da humanidade que quebra a criptografia da internet?

Sat, 05 Sep 2026 02:09:08 +0900

O que é o “General Number Field Sieve (GNFS)”, a matemática mais poderosa da humanidade que quebra a criptografia da internet?

A internet que usamos todos os dias. Mensagens no LINE, YouTube, compras na Amazon etc., todas as comunicações são protegidas por “criptografia”. Atualmente, a criptografia mais utilizada em todo o mundo é a “Criptografia RSA”.

O núcleo da defesa da Criptografia RSA é muito simples. Ele utiliza a propriedade matemática de que ** “a fatoração em números primos de números gigantescos não pode ser resolvida nem mesmo por computadores” ** . Por exemplo, para “15”, sabemos imediatamente que é “3 × 5”, mas no instante em que isso se torna um “número de 270 dígitos”, levaria centenas de milhões de anos para ser resolvido, mesmo se conectássemos todos os supercomputadores do mundo.

No entanto, os matemáticos não ficaram em silêncio. Para quebrar essa criptografia impenetrável, a humanidade criou um algoritmo (procedimento de cálculo) quase mágico chamado ** “General Number Field Sieve (GNFS)” ** .

Neste artigo, sem usar nenhum jargão técnico e apenas com o conhecimento da ** matemática do ensino fundamental (fatoração em primos, expressões algébricas, máximo divisor comum) ** , explicaremos passo a passo como esse “algoritmo mais forte da humanidade” quebra a criptografia!

Capítulo 1: O objetivo da decodificação é uma “fórmula da 8ª série”

O maior golpe especial para enfrentar a gigantesca fatoração em números primos. É essa fórmula aprendida na 8ª série:

** $X^2 - Y^2 = (X + Y)(X - Y)$ **

Você pode pensar: “Sério que uma fórmula tão básica pode quebrar a criptografia?”. No entanto, esta é a chave mestra que revela tudo.

O maior objetivo para quebrar a criptografia é, para um número gigante $N$, encontrar ** “números ($X$ e $Y$) onde o resto da divisão de $X^2$ e $Y^2$ por $N$ seja o mesmo” ** .

Por que “ter o mesmo resto” quebra a criptografia?

Suponha que dois números, $X^2$ e $Y^2$, tenham “o mesmo resto quando divididos por $N$”. Ter o mesmo resto significa que existe uma regra onde ** a subtração “$X^2 - Y^2$” será sempre perfeitamente divisível por $N$ (será um múltiplo de $N$) ** .

Aqui, vamos supor que o número gigante $N$ usado na criptografia seja composto pela multiplicação de dois números primos secretos ($p$ e $q$) ($N = p \times q$).

Fatorando $X^2 - Y^2$, obtemos ** $(X - Y)(X + Y)$ ** . O fato de isso ser um múltiplo de $N$ significa que, em algum lugar dessa multiplicação, os primos secretos $p$ e $q$ estão escondidos.

Aqui, um milagre acontece. Há uma probabilidade matemática de ** 50% (metade) ** de que os dois primos $p$ e $q$ se separem em salas diferentes: ** “$p$ vai para a sala de $(X - Y)$” e “$q$ vai para a sala de $(X + Y)$” ** .

Com apenas o primo $p$ tendo entrado na sala de $(X - Y)$, vamos calcular o ** “máximo divisor comum (a maior peça em comum)” ** de $(X - Y)$ e $N$.

Conteúdo de $(X - Y)$ = $p \times$ algum número
Conteúdo de $N$ = $p \times q$ A única peça comum é ** “$p$” ** !

Ou seja, no instante em que o máximo divisor comum é calculado, o número primo oculto $p$ é revelado e a criptografia é completamente decodificada. (*O máximo divisor comum pode ser calculado instantaneamente em um smartphone usando o “Algoritmo de Euclides”).

** 【Pequena Coluna: Por que o quadrado? Cubo ou o dobro não servem?】 **

Com “$2X - 2Y$”, torna-se $2(X - Y)$ e há apenas uma sala, então você não pode separar os primos. Com “$X^3 - Y^3$”, os tamanhos das salas ficam desequilibrados e o cálculo torna-se desnecessariamente pesado. Para separar os primos em dois, o “quadrado” que se divide perfeitamente em duas salas tem o melhor custo-benefício.

Capítulo 2: Como encontrar X e Y? “Quebra-cabeça de coleta de cartas de números primos”

O objetivo é claro. No entanto, mesmo se procurarmos cegamente por “$X^2$ e $Y^2$ que têm o mesmo resto”, o fim do universo chegaria antes de encontrá-los. Então, os matemáticos criaram um método genial chamado ** “quebra-cabeça de coleta de cartas de números primos” ** .

Step 1: Coletar apenas ouro em pó (números suaves) com uma peneira

Primeiro, prepare um número apropriado $Z$, eleve-o ao quadrado e calcule o resto $W$ ao dividi-lo por $N$. (O mundo dos restos de $Z^2 = W$)

Fatore o resto obtido $W$ em números primos. Aqui, apenas quando aparecer ** “um $W$ composto apenas de pequenos primos como 2, 3, 5, 7, etc.” ** , guarde essa equação como um “cartão premiado” e jogue-a fora se houver primos grandes misturados. É como jogar fora as pedras grandes com uma peneira num rio para coletar apenas o pó de ouro.

Step 2: O quebra-cabeça para tornar tudo “par”

Por exemplo, suponha que as 3 seguintes cartas de pó de ouro foram coletadas.

Carta A: $Z_1^2 = 2^3 \times 3^1$
Carta B: $Z_2^2 = 2^1 \times 5^1$
Carta C: $Z_3^2 = 3^1 \times 5^1$

Vamos multiplicar todos eles. O lado direito se torna $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, E ao organizá-los juntos, obtemos ** “$2^4 \times 3^2 \times 5^2$” ** .

Surpreendentemente, a quantidade de números primos tornou-se “4, 2, 2”, ** todos sendo um número par ** ! O fato de todos serem pares significa que se você reduzir a quantidade total pela metade, será “o quadrado de algo”. Ou seja, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

O lado esquerdo é $(Z_1 \times Z_2 \times Z_3)^2$, então finalmente chegamos a: ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** O tão esperado par “$X^2 = Y^2$” está completo!

Para computadores, o quebra-cabeça de calcular se a quantidade de números primos é “par ou ímpar (0 ou 1)” é algo em que eles são muito bons, então, com este método, é possível encontrar $X$ e $Y$ em alta velocidade.

Capítulo 3: A Parede do Desespero se ergue

Agora qualquer criptografia pode ser quebrada! …ou assim pensávamos, mas um grande problema ocorreu. Se o número da criptografia $N$ tiver até cerca de “100 dígitos”, este método (chamado Sieve Quadrático) pode resolvê-lo, mas quando $N$ se torna “200 ou 300 dígitos”, o $W$ que surge no meio do cálculo torna-se demasiado grande.

Quando os números ficam demasiado grandes, “números compostos apenas por pequenos números primos (pó de ouro)” deixam de aparecer. Torna-se mais difícil do que procurar lentes de contacto no deserto, e as cartas necessárias para resolver o quebra-cabeça não se acumulam de forma alguma.

Aqui, a arma final da humanidade, o ** “General Number Field Sieve (GNFS)” ** , finalmente entra em cena.

Capítulo 4: A ideia mais forte da humanidade de criar “Dois Mundos”

A ideia genial do GNFS é: ** “Os números tornam-se gigantescos porque calculamos apenas no mundo real. Então, vamos criar um ‘mundo dos bastidores’ usando polinómios (fórmulas com letras) para dividir o peso do cálculo em dois.” **

A magia das fórmulas com letras

O GNFS converte o número gigante $N$ em uma fórmula com letras, utilizando um número base $m$. Por exemplo, se $N=100$, com $m=4$, então $100 = 4^3 + 2(4^2) + 4$. Transformamos isso numa fórmula (o mundo dos bastidores) usando a letra $x$: ** $f(x) = x^3 + 2x^2 + x$ ** .

O mais interessante dessa fórmula é que ela possui a propriedade de que ** “se substituirmos $x$ por $m$ (4 no exemplo acima), sempre podemos voltar ao número real $N$” ** .

Procurando pó de ouro em 2 mundos simultaneamente

O GNFS cria muitos pares de números inteiros aleatórios $(a, b)$ e realiza os seguintes dois cálculos em simultâneo:

** Mundo Real ** : $a - b \times m$
** Mundo das Letras ** : O valor de $a - b \times x$ calculado pelas regras dos polinómios

Ao dividir o problema em dois mundos, o tamanho dos números tratados diminui (fica mais leve) drasticamente. É como dividir uma pedra gigante em dois para transformá-la em pedras mais fáceis de manusear.

Então, utilizamos uma peneira para separar e recolher apenas os pares milagrosos $(a, b)$ onde ** “tanto no mundo real quanto no mundo das letras, ambos são ‘compostos apenas de pequenos primos (pó de ouro)’” ** . Esta é a origem do nome “Crivo do Corpo de Números”.

O momento em que a criptografia é finalmente quebrada

Quando dezenas de milhões de “cartões de pó de ouro” são recolhidos de ambos os mundos, o supercomputador utiliza cálculos gigantescos de matrizes para encontrar “uma combinação em que o número de primos seja todo par”, tal como fizemos no Capítulo 2.

Assim que a combinação for encontrada:

Deixe o número ao quadrado no mundo real ser ** $X^2$ **
Deixe a fórmula quadrada criada no mundo das letras ser ** $Y(x)^2$ **

Por fim, substitua $x$ na fórmula de letras $Y(x)$ por $m$, saltando de volta para o mundo real e unindo-os. Então, como que por magia matemática, a condição onde ** “os restos de $X^2$ e $Y^2$ são iguais” ** é estritamente alcançada!

O resto, como no Capítulo 1, é apenas calcular o máximo divisor comum entre $X - Y$ e $N$, e a impenetrável criptografia RSA desmoronará, revelando os primos secretos.

Conclusão: A matemática não acaba

Você pode estar a pensar: “Fantástico, com o GNFS qualquer criptografia pode ser quebrada!”. No entanto, a criptografia RSA também não se deu por vencida. O que é utilizado na internet atual é um número gigantesco e monstruoso chamado “RSA-2048 (cerca de 617 dígitos)”.

Por mais que o GNFS seja o algoritmo mais poderoso da humanidade, diz-se que para resolver até mesmo 270 dígitos (RSA-270), levaria milhares ou dezenas de milhares de anos, mesmo conectando computadores do mundo inteiro. Por agora, os nossos dados bancários e do LINE estão seguros.

Mas e se aparecesse uma ** “magia capaz de encontrar instantaneamente $X$ e $Y$ para qualquer número gigante” ** ? Na verdade, a coisa mais próxima disso é o ** “Computador Quântico (Algoritmo de Shor)” ** , que está atualmente em desenvolvimento. Utilizando a natureza ondulatória da mecânica quântica, foi provado matematicamente que é possível ignorar o aborrecido quebra-cabeças da recolha de cartas e chegar à resposta de uma só vez.

A interminável batalha de inteligência entre os que criam a criptografia (defesa) e os que criam algoritmos para a quebrar (ataque). Saber que a “fatoração em números primos” e as “fórmulas com letras” ensinadas na escola secundária são, na verdade, as armas na linha da frente da segurança global não faz com que as aulas de matemática pareçam um pouco mais interessantes?

Quem descobrirá o algoritmo mais forte do futuro poderá ser você, que está a ler este artigo!

(※Este artigo é uma adaptação conceptual do encanto matemático da quebra de códigos para estudantes. O GNFS real é rigorosamente calculado utilizando matemática universitária avançada, tal como os grupos da classe de ideais dos corpos numéricos algébricos e homomorfismos)