Criptografia on kenji.blog

【PQC】A Visão Geral da "Criptografia Pós-Quântica", a Criptografia da Próxima Geração na Era da Computação Quântica

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

Introdução: A “Ameaça” dos Computadores Quânticos à Criptografia

Atualmente, muitas das comunicações que realizamos diariamente na internet —— desde pagamentos em serviços bancários online, navegação em sites (HTTPS), troca de mensagens em aplicativos, até transações de blockchain e criptomoedas —— são protegidas por uma tecnologia chamada “criptografia de chave pública”. Especificamente, algoritmos como a criptografia RSA e a criptografia de curva elíptica (ECC) são os pilares que sustentam a confiabilidade da nossa sociedade digital moderna.

Esses métodos de criptografia baseiam sua segurança em problemas matemáticos complexos, como a “fatoração de números primos gigantes” e o “problema do logaritmo discreto”, que levariam um tempo astronômico para serem resolvidos por computadores clássicos atuais (incluindo supercomputadores). No entanto, com a concretização dos “computadores quânticos” , que têm feito progressos notáveis nos últimos anos, essa premissa será fundamentalmente derrubada.

O “Algoritmo de Shor”, publicado por Peter Shor em 1994, provou matematicamente que, se usarmos um computador quântico com desempenho suficiente, poderemos resolver a fatoração de números primos e o problema do logaritmo discreto em um tempo extremamente curto. Isso significa que a comunicação criptografada que protege a internet hoje corre o risco de ser totalmente decodificada no futuro (um problema conhecido como Y2Q: Years to Quantum, ou Q-Day).

Ainda mais grave é a existência de um método de ataque chamado “Harvest Now, Decrypt Later” (Roube agora, decifre depois). Dados que precisam manter a confidencialidade por décadas, como informações confidenciais de estados, propriedade intelectual corporativa e informações biométricas pessoais, já podem ser alvo de roubo hoje, com a intenção de serem decodificados no futuro.

Para responder a essa crise sem precedentes, criptógrafos e instituições de pesquisa em todo o mundo estão trabalhando juntos para desenvolver a criptografia de próxima geração que pode manter a segurança mesmo contra ataques de computadores quânticos, a Criptografia Pós-Quântica (PQC) . Neste artigo, explicaremos em detalhes desde os fundamentos da PQC até os mecanismos de seus principais algoritmos e as tendências mais recentes de padronização global lideradas pelo Instituto Nacional de Padrões e Tecnologia dos EUA (NIST).

O que é a Criptografia Pós-Quântica (PQC)?

A Criptografia Pós-Quântica (Post-Quantum Cryptography, PQC) é um termo genérico para algoritmos de criptografia projetados para operar em computadores clássicos existentes e, ao mesmo tempo, serem resistentes a ataques (como o algoritmo de Shor) de computadores quânticos de grande escala que surgirão no futuro.

Tecnologias frequentemente confundidas com ela são a “Criptografia Quântica (Quantum Cryptography)” e a “Distribuição Quântica de Chaves (QKD)”, mas estas são abordagens completamente diferentes. A criptografia quântica (QKD) é uma tecnologia baseada em hardware que utiliza as leis físicas da mecânica quântica (como a propriedade de que o estado muda ao ser observado) para tornar a espionagem nos canais de comunicação fisicamente impossível. Ela requer fibras ópticas dedicadas e equipamentos especiais, enfrentando desafios como custos de implementação e limitações de distância.

Por outro lado, a PQC é uma tecnologia de criptografia baseada em software, fundamentada puramente em “matemática” . Portanto, ela pode ser incorporada à infraestrutura de internet existente, servidores, smartphones, navegadores, etc., como uma atualização de software, sendo altamente aplicável ao mundo real. Empresas de TI e governos de todo o mundo consideram urgente substituir (migrar) o RSA e o ECC atualmente em uso por esta PQC.

As 4 Principais Abordagens Matemáticas que Sustentam a PQC

Vários algoritmos de PQC foram propostos, baseando-se em problemas matemáticos complexos (como problemas NP-difíceis) que não podem ser resolvidos de forma eficiente mesmo com um computador quântico. Aqui, apresentaremos as 4 principais categorias que dominam atualmente.

Principais Abordagens da Criptografia Pós-Quântica (PQC)

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


graph LR
 PQC[Criptografia Pós-Quântica PQC] --> L[Criptografia baseada em reticulados Lattice-based]
 PQC --> H[Criptografia baseada em hash Hash-based]
 PQC --> M[Criptografia multivariada Multivariate]
 PQC --> C[Criptografia baseada em códigos Code-based]

 L --> L1(FIPS 203: ML-KEM)
 L --> L2(FIPS 204: ML-DSA)

 H --> H1(FIPS 205: SLH-DSA)

 style PQC fill:#f9f,stroke:#333,stroke-width:2px

1. Criptografia baseada em reticulados (Lattice-based Cryptography)

Atualmente, esta “criptografia baseada em reticulados” é considerada a mais promissora e é a principal tendência no campo da PQC. A criptografia de reticulados baseia sua segurança em problemas relacionados a pontos dispostos regularmente (pontos de reticulado) em um espaço multidimensional. Problemas famosos incluem o “Problema do Vetor Mais Curto (SVP: Shortest Vector Problem)” e o “Problema de Aprendizado com Erros (LWE: Learning With Errors)”.

Visão geral do mecanismo: Imagine que inumeráveis pontos estão dispostos em forma de grade (reticulado) dentro de um espaço de dimensão muito alta (centenas a milhares de dimensões). Encontrar um ponto de reticulado específico é fácil em 2 ou 3 dimensões, mas quando se trata de centenas de dimensões, ainda não foi descoberto nenhum algoritmo que o encontre de forma eficiente, seja em um computador clássico ou quântico. O problema LWE, em particular, utiliza a propriedade de que “se você adicionar propositalmente um pequeno ‘ruído (erro)’ a um sistema de equações lineares, torna-se drasticamente mais difícil adivinhar as variáveis originais”.

Vantagens:

Aplicável tanto ao compartilhamento de chaves (KEM) quanto às assinaturas digitais.
A velocidade de processamento é muito rápida (em alguns casos, mais rápida que RSA e ECC).
O tamanho da chave e o tamanho do texto cifrado são relativamente pequenos, oferecendo um bom equilíbrio.

Muitos dos algoritmos atualmente sendo padronizados pelo NIST (como ML-KEM e ML-DSA) adotam essa criptografia baseada em reticulados.

2. Criptografia baseada em hash (Hash-based Cryptography)

A criptografia baseada em hash é um algoritmo PQC especializado em assinaturas digitais. A base de sua segurança depende exclusivamente da resistência à colisão e da unidirecionalidade de “funções de hash criptográficas” seguras, como SHA-2 e SHA-3.

Visão geral do mecanismo: Ela tem como ponto de partida um esquema de assinatura descartável de uso único (assinatura de uso único) chamado “Assinatura Lamport (Lamport Signature)”. Ao agrupar isso em um formato de dados em estrutura de árvore chamado “Árvore de Merkle (Merkle Tree)”, possibilita múltiplas assinaturas com um único par de chaves.

Vantagens:

A base de segurança é extremamente robusta, com a forte prova de que “é segura desde que a função de hash seja segura”.
Como a dependência de estruturas matemáticas é baixa, o risco de serem descobertos métodos inesperados de decodificação é menor.

Desvantagens:

Não pode ser usada para compartilhamento de chaves (KEM), servindo apenas para assinaturas digitais.
O tamanho da assinatura tende a ser grande.
Existem as modalidades “stateful” (com estado) e “stateless” (sem estado). A versão stateful (como XMSS) requer um gerenciamento rigoroso do número de vezes que a chave é usada, tornando a implementação mais difícil.

O NIST padronizou o “SLH-DSA (anteriormente SPHINCS+)” como uma assinatura baseada em hash stateless.

3. Criptografia multivariada (Multivariate Cryptography)

A criptografia de polinômios multivariados baseia sua segurança na dificuldade de resolver um sistema de equações polinomiais quadráticas simultâneas com muitas variáveis (Problema MQ: Multivariate Quadratic problem). Sabe-se que este problema é NP-difícil.

Visão geral do mecanismo: O remetente cria um texto cifrado (assinatura) substituindo o texto simples (ou valor de hash) em uma equação complexa com muitas variáveis fornecida como chave pública. O destinatário legítimo possui como chave privada uma “informação oculta (alçapão) que converte a estrutura da equação em uma forma fácil de resolver”, usando-a para realizar a decodificação (ou verificação de assinatura).

Vantagens:

O tamanho da assinatura é muito pequeno.
A velocidade de verificação da assinatura é extremamente alta. É adequado para dispositivos de IoT com recursos limitados.

Desvantagens:

O tamanho da chave pública é muito grande (pode chegar a dezenas ou centenas de kilobytes).
No passado, algoritmos proeminentes (como Rainbow) foram quebrados por ataques clássicos, tornando mais difícil estabelecer a confiança na segurança em comparação com outros métodos.

4. Criptografia baseada em códigos (Code-based Cryptography)

A criptografia baseada em códigos aplica a teoria dos “códigos de correção de erros”, usados para corrigir erros nos canais de comunicação, à criptografia. A “Criptografia McEliece”, proposta em 1978, é a mais famosa e uma das mais antigas entre as PQC.

Visão geral do mecanismo: O remetente codifica o texto simples usando a chave pública do destinatário (a matriz geradora de um código de correção de erros que oculta uma estrutura específica), adiciona um erro intencional (ruído) e o envia. O destinatário usa a chave privada para remover o erro e extrair o texto simples. Um decodificador precisaria corrigir os erros a partir de um código aleatório sem conhecer sua estrutura; isso é chamado de “problema geral de decodificação de síndrome”, que é comprovadamente NP-difícil.

Vantagens:

Tendo sido exaustivamente estudada por mais de 40 anos e sem nenhum ataque eficaz encontrado até agora, a confiança na sua segurança é extremamente alta.
Os processos de criptografia e descriptografia são rápidos.

Desvantagens:

O tamanho da chave pública é imenso (pode chegar a vários megabytes). Portanto, é difícil usá-la em ambientes com limitações de largura de banda de comunicação ou memória (como no handshake de TLS).

Tendências Recentes na Padronização PQC pelo NIST

O Instituto Nacional de Padrões e Tecnologia dos EUA (NIST) iniciou em 2016 uma chamada global para algoritmos de criptografia pós-quântica de próxima geração, realizando avaliações rigorosas e várias rodadas de análises ao longo de anos.

Em 2024, o NIST finalmente anunciou os seguintes três algoritmos como Padrões Federais de Processamento de Informações (FIPS) oficiais. Isso concluiu a formação de uma base sólida para que organizações em todo o mundo comecem a implementá-los em ambientes de produção.

Padrões FIPS Estabelecidos (2024)

FIPS 203: ML-KEM (Nome anterior: CRYSTALS-Kyber)
- Uso: Mecanismo de encapsulamento de chaves (KEM) / Criptografia e compartilhamento de chaves
- Tecnologia base: Criptografia baseada em reticulados (Module-LWE)
- Características: Oferece um excelente equilíbrio entre o tamanho da chave e a velocidade. Servirá como o compartilhamento de chaves PQC padrão para usos comuns da internet, como comunicação na Web (TLS) e aplicativos de mensagens seguros.
FIPS 204: ML-DSA (Nome anterior: CRYSTALS-Dilithium)
- Uso: Assinatura digital
- Tecnologia base: Criptografia baseada em reticulados (Module-LWE)
- Características: O principal padrão para assinaturas digitais. Permite processamento eficiente, tornando-se o novo padrão para todas as aplicações de assinatura eletrônica, como assinaturas de software e autenticação de documentos.
FIPS 205: SLH-DSA (Nome anterior: SPHINCS+)
- Uso: Assinatura digital
- Tecnologia base: Criptografia baseada em hash (stateless)
- Características: Desempenha um papel vital como um backup caso vulnerabilidades sejam descobertas na criptografia baseada em reticulados no futuro. Embora o tamanho da assinatura seja grande, é adequado para aplicações que exigem confiabilidade de longo prazo.

Busca por Maior Diversidade

Embora o NIST tenha concluído o processo inicial de padronização, ele continua buscando mais algoritmos. Especialmente porque os padrões estão muito inclinados para a “criptografia baseada em reticulados”, a garantia da diversidade de algoritmos (Crypto Diversity) é altamente valorizada. A avaliação da criptografia baseada em códigos e outros métodos está em andamento como padrão de backup para compartilhamento de chaves, e a base da PQC deve se tornar ainda mais robusta no futuro.

Cenários e Desafios da Transição para a PQC: A Importância da “Agilidade Criptográfica”

Com o lançamento de padrões oficiais pelo NIST, agências governamentais, instituições financeiras e empresas de tecnologia em todo o mundo acelerarão a transição (migração) do RSA/ECC existente para a PQC. Diretrizes de agências como a NSA (Agência de Segurança Nacional dos EUA) também recomendam a conclusão antecipada dessa transição.

Adoção da Abordagem Híbrida

Como os algoritmos PQC são novos, eles não passaram pelo “teste do tempo” em comparação com a criptografia clássica. Considerando os riscos de bugs ocultos em implementações ou a descoberta de novos métodos de ataque, recomenda-se uma “abordagem híbrida” durante o período de transição. Isso envolve realizar a troca de chaves combinando criptografia existente e comprovada (por exemplo, ECDHE) com a nova PQC (por exemplo, ML-KEM). Atualmente, as principais implementações de teste dessa abordagem estão avançando rapidamente em navegadores e serviços em nuvem.

Atingindo a Agilidade Criptográfica (Crypto-Agility)

O que empresas e desenvolvedores de sistemas devem ter mais em mente daqui para frente é garantir a “Agilidade Criptográfica (Crypto-Agility)” . É essencial ter um projeto arquitetônico flexível que permita a substituição e atualização rápida dos algoritmos de criptografia sem paralisar o sistema, caso falhas sejam encontradas nos algoritmos no futuro ou surjam novos padrões.

Criar um inventário criptográfico (CBOM: Cryptography Bill of Materials) que identifique com precisão “onde”, “qual criptografia” e “para qual propósito” está sendo usada dentro do sistema da empresa é um primeiro passo vital em direção à transição para PQC.

Conclusão: Preparando-se para o “Q-Day” Iminente

A evolução dos computadores quânticos trará enormes benefícios à humanidade, mas ao mesmo tempo representa a maior ameaça à segurança criptográfica que é a base de nossa sociedade digital moderna. A Criptografia Pós-Quântica (PQC) não é mais um “tema de pesquisa para um futuro distante”. Com o marco da publicação dos padrões FIPS pelo NIST, a PQC entrou na fase de “implementação e transição” em larga escala.

Considerando a ameaça do “Harvest Now, Decrypt Later”, a transição para a PQC é a maior prioridade a ser tratada “agora mesmo” por todas as organizações que lidam com dados altamente confidenciais. Ao entender profundamente as tecnologias de criptografia de próxima geração e aumentar a agilidade criptográfica dos sistemas, poderemos superar com segurança a iminente era dos computadores quânticos.

【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)

Princípio de Kerckhoffs

Wed, 16 Apr 2025 23:53:08 +0900

“Princípio de Kerckhoffs”

Olá!

Hoje eu gostaria de falar sobre algo um pouco interessante e, na verdade, extremamente importante chamado “Princípio de Kerckhoffs”.

Ah, espere, espere.
Alguns de vocês podem pensar: “Nunca ouvi falar do ‘Princípio de Kerckhoffs’ e tem muitos termos técnicos…”. Não se preocupe. Este artigo é exatamente o que eu quero que pessoas como você leiam.

O que significa “criptografia segura”?

Por exemplo, digamos que alguém diga: “Este cofre só pode ser aberto por alguém que saiba a maneira secreta de abri-lo”.

À primeira vista, isso parece muito seguro, não é?
Mas, se você pensar bem, não é um pouco preocupante?

Como, “Se o segredo for revelado, é o fim?”.

Na verdade, foi isso que desencadeou o surgimento do Princípio de Kerckhoffs.

O que é o “Princípio de Kerckhoffs” afinal?

Explicando de forma bem simples, é a ideia de que

“A criptografia deve ser segura mesmo se o seu funcionamento for descoberto” .

Em outras palavras, “A segurança deve depender apenas da ‘chave secreta’, e o método de criptografia em si pode ser público!”.

Por outro lado, “Um estado em que o algoritmo (mecanismo) de criptografia é mantido em segredo é considerado de baixa confiabilidade”.

“Se o mecanismo for secreto, é seguro” pode ser um pouco perigoso

Essa é uma maneira comum de pensar:

“Não mostrei o interior deste aplicativo a ninguém, então a segurança está ok”

Eu entendo o sentimento.
Mas isso é o mesmo que dizer: “Ninguém está olhando, então nenhum ponto fraco será encontrado, certo?”.

Na realidade, o próprio fato de que “ninguém está olhando” pode se tornar um risco.

Mas por que esse princípio é importante?

Porque, se alguém colocar as mãos no mecanismo e puder decifrá-lo facilmente, essa criptografia está acabada.

Para usar uma analogia, é como se a fechadura de uma porta tivesse um mecanismo muito complexo, mas na verdade pudesse ser aberta com uma chave reserva feita em uma loja de artigos de um dólar.

O importante não é “A chave é secreta, então está tudo bem”, mas “Mesmo se você mostrar todo o mecanismo, ele não pode ser aberto sem a chave certa”.

A sensação de “Mas isso não é um pouco assustador?”

O que muitas pessoas sentem aqui é a ansiedade de

“Não é meio assustador expor todo o mecanismo?”

Eu entendo.
Porque você pensa: “Se eu mostrar o interior inteiro, não será imitado ou usado para o mal?”.

Mas esse é exatamente o cerne do Princípio de Kerckhoffs.
A “força que não entra em colapso mesmo quando o interior é mostrado” é a verdadeira segurança.

Dito isso, requer um pouco de coragem no começo

Colocando-se no lugar do desenvolvedor, parece que “publicar o mecanismo = revelar suas fraquezas”, então é claro que é de dar frio na barriga.

Mas pense sobre isso.

Algo que você pode mostrar adequadamente e dizer: “Qualquer um pode verificar”, acabará sendo mais confiável.

Isso é semelhante às relações humanas.

Você pode se sentir mais seguro com “uma pessoa que se dá bem com você depois de mostrar o seu verdadeiro eu”.

Conclusão

O Princípio de Kerckhoffs pode soar um pouco teórico, mas sua essência é muito simples.

É apenas uma questão de “Vamos criar um sistema que não quebre, não importa para quem você o mostre” .

Um design adequado em vez de segredos superficiais.
Código do qual você não se envergonha de mostrar, em vez de código que você não quer que ninguém veja.

Talvez esse tipo de “força” seja cada vez mais necessário na próxima era.

Muito obrigado por ler!

A segurança é um assunto um pouco difícil, mas há partes que se conectam a “relacionamentos com pessoas” e “paz de espírito cotidiana”.
Se você aprender um pouco de cada vez sem se sentir sobrecarregado, tenho certeza de que coisas boas acontecerão.