RSA on kenji.blog

¿Realmente las computadoras cuánticas destruirán el cifrado RSA? ~ El algoritmo de Shor y el estado actual ~

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

Introducción: La intersección entre la criptografía y la computación cuántica

En la sociedad de Internet moderna, la base para proteger el secreto de las comunicaciones es la “criptografía de clave pública”. Entre ellas, un representante típico es el “cifrado RSA”, desarrollado en 1977 por Ron Rivest, Adi Shamir y Leonard Adleman. Desde los pagos en compras en línea que utilizamos todos los días, la navegación de sitios web (HTTPS) hasta el envío y recepción de correos electrónicos, el cifrado RSA funciona como el corazón de la infraestructura de Internet.

Sin embargo, con la llegada de las “computadoras cuánticas”, se ha señalado la posibilidad de que esta seguridad se vea socavada desde sus cimientos. A veces, en los medios de comunicación aparecen titulares sensacionalistas como: “Si se perfecciona la computadora cuántica, las contraseñas y códigos de todo el mundo serán descifrados en segundos”. Pero, ¿es esto realmente cierto?

En este artículo, profundizaremos en los mecanismos del GNFS (Criba General del Cuerpo de Números), que es un método clásico de criptoanálisis, y el “Algoritmo de Shor” (Shor’s Algorithm), que es la versión definitiva del algoritmo de descifrado utilizando computadoras cuánticas. Explicaremos de manera sencilla conceptos avanzados como la transformada cuántica de Fourier y el hallazgo de períodos, y examinaremos en detalle el estado actual del hardware cuántico en la era actual NISQ (Noisy Intermediate-Scale Quantum) y los obstáculos necesarios para romper realmente RSA-2048.

La base del cifrado RSA: La dificultad de la factorización de enteros

La seguridad del cifrado RSA depende de una asimetría extremadamente simple en matemáticas. Es el hecho de que “multiplicar dos números primos gigantescos es fácil, pero encontrar (factorizar) los dos números primos originales a partir del resultado multiplicado (número compuesto) es extremadamente difícil”.

Por ejemplo, supongamos que hay dos números primos $ p = 61 $ y $ q = 53 $. Calcular esta multiplicación $ N = p \times q = 3233 $ es instantáneo. Sin embargo, si solo se da el número “3233” y se nos pide resolver “¿de qué números primos es esta la multiplicación?”, a medida que el número crece, la cantidad de cálculo explota exponencialmente.

En el RSA-2048, que es la corriente principal en la actualidad, la longitud de la clave es de 2048 bits, es decir, se utiliza un gigantesco número compuesto $ N $ de unos 617 dígitos decimales. Si este $ N $ pudiera ser factorizado, el cifrado estaría prácticamente descifrado.

El desafío de las computadoras clásicas: GNFS (Criba General del Cuerpo de Números)

Para resolver el problema de la factorización, matemáticos y criptógrafos han desarrollado varios algoritmos a lo largo de los años. Entre ellos, el que actualmente se considera el más rápido en computadoras clásicas es la Criba General del Cuerpo de Números (GNFS: General Number Field Sieve).

GNFS es un método para factorizar un número gigantesco $ N $ extendiendo el cálculo en el anillo de enteros a un cuerpo de números algebraicos más abstracto (Number Field) para su análisis. El flujo general es el siguiente:

Selección de polinomios : Encontrar un polinomio $ f(x) $ con el grado y los coeficientes adecuados que tenga a $ N $ como raíz.
Recopilación de datos (cribado) : Buscar en el cuerpo de los números racionales y en el cuerpo algebraico una gran cantidad de pares de números que se puedan descomponer en números primos pequeños (números suaves, Smooth numbers). Este proceso se llama “cribado” y es la parte que requiere más tiempo.
Generación y reducción de matrices : Generar una matriz dispersa gigante (una matriz donde la mayoría de los componentes son 0) basada en las relaciones recopiladas, y usar métodos de álgebra lineal (como el método de Block-Lanczos) para encontrar una solución.
Cálculo de raíces cuadradas : Finalmente, calcular la raíz cuadrada sobre el cuerpo algebraico para derivar los factores (factores primos) de $ N $.

La complejidad computacional de GNFS se evalúa asintóticamente como $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $. Esto se llama complejidad temporal “subexponencial” (Sub-exponential). Aunque es más rápido que el tiempo exponencial, es mucho más lento que el tiempo polinómico (Polynomial time).

De hecho, en 2020, un equipo de investigación internacional logró factorizar el RSA-250 (un número compuesto de 829 bits y 250 dígitos) utilizando GNFS. Este cálculo consumió un enorme tiempo de computación de aproximadamente 2700 CPU core-años, reuniendo recursos informáticos de todo el mundo. Sin embargo, cuando se trata de 2048 bits, se menciona que la cantidad de cálculo necesaria aumentaría a billones de veces la edad del universo, por lo que no importa cuántas supercomputadoras actuales funcionen en paralelo, es imposible descifrarlo en un tiempo realista utilizando métodos clásicos.

La carta de triunfo de la computadora cuántica: El algoritmo de Shor

Aquí es donde entra en juego el “Algoritmo de Shor”, publicado por Peter Shor en 1994. Este algoritmo fue revolucionario al poder resolver el problema de la factorización de enteros en una computadora cuántica en tiempo polinómico ( $ O((\log N)^3) $ ). La diferencia entre el tiempo subexponencial y el tiempo polinómico es decisiva, lo que significa que, en teoría, el uso de una computadora cuántica destruiría por completo el cifrado RSA.

Flujo general del algoritmo de Shor

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[Ingresar el número N a factorizar] --> B[Seleccionar un número entero aleatorio a]
 B --> C{Máximo común divisor<br>de a y N}
 C -->|Mayor que 1| D[¡Afortunadamente encontramos un factor primo!]
 C -->|1 Coprimos| E[Turno de la computadora cuántica]
 E --> F[Encontrar el período r de la función<br>f_x = a^x mod N mediante<br>la transformada cuántica de Fourier]
 F --> G{¿Es el período r par y<br>a^r/2 ≢ -1 mod N?}
 G -->|Sí| H[Calcular el máximo común divisor gcd_a^r/2 ± 1, N]
 H --> I((¡Factorización exitosa!))
 G -->|No| B

El algoritmo de Shor no resuelve directamente el problema de la factorización, sino que utiliza teoremas de la teoría de números para convertirlo en otro problema llamado “Problema de hallazgo de períodos” (Period Finding Problem), y aborda resolverlo rápidamente aprovechando las características de las computadoras cuánticas.

Paso 1: Reducción de la factorización al problema de hallazgo de períodos (Procesamiento clásico)

El primer paso del algoritmo se realiza en una computadora clásica. Para el número $ N $ que queremos factorizar, elegimos un entero aleatorio $ a $ ( $ 1 < a < N $ ) que sea coprimo con $ N $ (su máximo común divisor es 1). Si, por casualidad, el máximo común divisor no es 1, entonces el divisor común encontrado en ese punto es un factor primo de $ N $ y el descifrado está completo, pero la probabilidad es extremadamente baja.

Luego, consideramos la siguiente secuencia de ecuaciones modulares: $ f(x) = a^x \pmod N $

Si sustituimos $ x = 1, 2, 3, \dots $ en esta función $ f(x) $, los valores parecen ser aleatorios, pero dado que estamos calculando dentro de un rango finito, inevitablemente volverá al valor original en algún punto y repetirá la misma secuencia de números. A este período de repetición lo llamamos $ r $. Es decir, $ a^r \equiv 1 \pmod N $ El problema de encontrar el entero positivo más pequeño $ r $ que cumpla con esto, es el “Problema de hallazgo de períodos”.

Si se encuentra este período $ r $, y si $ r $ es par, entonces $ a^r - 1 \equiv 0 \pmod N $, y usando la fórmula de factorización se puede transformar en: $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $ A partir de aquí, al calcular el máximo común divisor de $ N $ y $ a^{r/2} \pm 1 $ usando el algoritmo de Euclides, se puede obtener un factor primo de $ N $ con una probabilidad extremadamente alta.

Para encontrar el período $ r $ en una computadora clásica, en última instancia, se requieren pasos exponenciales y no se puede acelerar. Sin embargo, una computadora cuántica puede encontrar este período $ r $ en un instante (en tiempo polinómico).

Paso 2: Preparación del estado cuántico y superposición

A partir de aquí es el turno de la computadora cuántica. Las computadoras cuánticas utilizan “cúbits” (Qubits) que pueden tener los estados “0” y “1” simultáneamente. En el algoritmo de Shor, se preparan dos registros: un registro para almacenar la entrada (el primer registro) y un registro para almacenar los resultados del cálculo (el segundo registro).

Primero, se aplica una operación de puerta cuántica llamada Puerta de Hadamard (Hadamard gate) a todos los cúbits del primer registro. Como resultado, el primer registro se convierte en un estado de superposición uniforme de todos los valores posibles de $ x $ (desde $ 0 $ hasta $ 2^n-1 $, donde $ n $ es un número de bits suficientemente grande).

En otras palabras, dentro de la computadora cuántica se crea un estado en el que existen de manera simultánea y paralela innumerables valores de entrada $ x=0, 1, 2, 3, \dots $.

Paso 3: Exponenciación modular cuántica (Quantum Modular Exponentiation)

A continuación, tomando el estado de superposición del primer registro como entrada, calculamos $ f(x) = a^x \pmod N $ y almacenamos el resultado en el segundo registro. Dado que este cálculo se ejecuta como una transformación unitaria en el circuito cuántico, el cálculo de $ f(x) $ para todos los $ x $ se realiza “simultáneamente y en paralelo (paralelismo cuántico)” manteniendo la superposición.

En este punto, el espacio general del sistema cuántico es: $ |x, a^x \bmod N\rangle $ que es una enorme superposición de estados.

Sin embargo, si simplemente medimos (observamos) el segundo registro aquí, un valor aleatorio de $ a^x \bmod N $ se elegirá probabilísticamente, y en conjunto con esto, el $ x $ del primer registro también se fijará a uno solo. Hacer esto equivaldría a calcularlo una vez en una computadora clásica y no nos permitiría encontrar el período $ r $.

Bajo las reglas de la mecánica cuántica, no podemos mirar directamente el contenido de un estado de superposición. Entonces, ¿cómo extraemos la información global, que es el “período” de todo el sistema?

Paso 4: Transformada Cuántica de Fourier (QFT: Quantum Fourier Transform)

La verdadera genialidad del algoritmo de Shor para superar este obstáculo es la aplicación de la Transformada Cuántica de Fourier (QFT) al primer registro.

Antes de realizar la medición, analizamos las propiedades de onda de la función $ f(x) $. Supongamos que observamos el segundo registro. Asumamos que se obtuvo un valor $ y $. Entonces, el estado del primer registro colapsa en “la superposición de todos los $ x $ tal que $ a^x \pmod N = y $”. Los valores de este $ x $ estarán separados por un intervalo del período $ r $ de la forma $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $, resultando en un estado discretamente alineado (una especie de distribución de amplitud de probabilidad en forma de peine).

Aplicamos la Transformada Cuántica de Fourier (QFT) a este estado. Así como la transformada discreta de Fourier clásica convierte una señal en el dominio del tiempo al dominio de la frecuencia, la QFT causa interferencia en las amplitudes de probabilidad del estado cuántico.

Al aplicar la QFT, debido al efecto de interferencia cuántica, las probabilidades de respuestas incorrectas que no resuenan (están desfasadas) con el período $ r $ se anulan mutuamente y se acercan a cero (interferencia destructiva), y solo se amplifica la probabilidad de la respuesta correcta que tiene la información del período $ r $ (interferencia constructiva).

Paso 5: Medición y expansión en fracciones continuas (Post-procesamiento clásico)

Si se mide el primer registro después de aplicar la QFT, con una probabilidad muy alta se obtendrá un entero $ c $ muy cercano a la forma $ c \approx \frac{j \cdot 2^n}{r} $ (donde $ j $ es un número entero desconocido y $ 2^n $ es el tamaño del registro).

Este resultado de medición $ c $ se devuelve a la computadora clásica para crear una fracción $ \frac{c}{2^n} \approx \frac{j}{r} $. Luego, calculando una aproximación utilizando un método matemático llamado “expansión en fracciones continuas” (Continued fraction expansion), podemos extraer de manera brillante el período $ r $ que está en el denominador.

Una vez que conocemos $ r $, todo lo que queda es usar la fórmula del Paso 1 para calcular los factores primos de $ N $ y el cifrado RSA estará completamente descifrado.

El poder y los desafíos de las computadoras cuánticas actuales (NISQ)

El algoritmo de Shor es teóricamente perfecto, pero si se pregunta “¿Se romperá el cifrado RSA mañana?”, la respuesta es claramente “no”. La razón radica en las limitaciones de la tecnología de hardware de las computadoras cuánticas actuales.

La era NISQ (Noisy Intermediate-Scale Quantum)

En la actualidad nos encontramos en una era llamada “NISQ”. Los dispositivos NISQ tienen decenas a cientos de cúbits físicos, pero son extremadamente vulnerables al ruido.

Los cúbits son susceptibles a influencias ambientales externas como el calor y las ondas electromagnéticas, lo que hace que ocurra con frecuencia la “decoherencia” (pérdida de entrelazamiento cuántico), que destruye el estado cuántico, o los “errores de puerta” al operar las puertas cuánticas. Si se intenta ejecutar un circuito cuántico muy profundo (con una cantidad masiva de pasos de cálculo) como el algoritmo de Shor, los errores se acumulan durante el cálculo y el resultado final será ruido completo sin significado.

Cúbits físicos y cúbits lógicos

Para resolver este problema de errores, es indispensable la “Corrección de errores cuánticos” (Quantum Error Correction). Aunque también se utilizan códigos de corrección de errores en las computadoras clásicas, la corrección de errores cuánticos es muy compleja debido al “Teorema de no clonación cuántica” que prohíbe copiar estados cuánticos.

En la corrección de errores cuánticos, se utilizan tecnologías como el “Código de superficie” (Surface Code) para combinar muchos “cúbits físicos” ruidosos, y así crear un “cúbit lógico” ideal y sin errores.

Teniendo en cuenta las tasas de error actuales, se estima que se necesitarán aproximadamente de 1,000 a 10,000 cúbits físicos para crear un solo cúbit lógico. Esto se denomina la “sobrecarga de la corrección de errores”.

¿Cuáles son los recursos necesarios para destruir RSA-2048?

Entonces, para descifrar realmente RSA-2048, ¿cuántos recursos se necesitan para ejecutar el algoritmo de Shor?

En una estimación de recursos revolucionaria realizada en un artículo de 2021 por Craig Gidney (Google) y Martin Ekerå, utilizando un algoritmo de Shor optimizado y realizando la corrección de errores con código de superficie, se requerirían los siguientes recursos:

Número de cúbits lógicos : Aproximadamente 4,096
Número de cúbits físicos ** : ** Aproximadamente 20 millones (asumiendo una tasa de error de alrededor de $10^{-3}$)
Tiempo de cálculo : Aproximadamente 8 horas (se requieren de millones a miles de millones de operaciones de puertas físicas)

Por el contrario, ¿cuál es el nivel alcanzado por el hardware cuántico actual? A finales de 2023, el procesador cuántico superconductor “Condor”, anunciado por IBM, tiene 1,121 cúbits. Además, también han aparecido investigaciones innovadoras sobre la generación de cúbits lógicos (como la generación de 48 cúbits lógicos utilizando una computadora cuántica de átomos neutros por la Universidad de Harvard y la empresa QuEra), pero aún no estamos en la etapa en que se puedan ejecutar “cálculos perfectos sin ruido” de manera continua y prolongada.

Para escalar desde unos miles de cúbits físicos hasta 20 millones de cúbits físicos prácticos (y un sistema interconectado, operando de manera estable a temperaturas criogénicas y capaz de procesar señales de control a ultra alta velocidad) existe un muro de ingeniería tremendo (problemas de cableado, límites de capacidad de enfriamiento y la expansión excesiva de la electrónica de control). Muchos expertos predicen que tomará al menos de 10 a 30 años, o incluso más, lograr una “Computadora cuántica tolerante a fallas (FTQC)” capaz de descifrar RSA-2048.

La inminente amenaza de “Store Now, Decrypt Later” y el amanecer de PQC

Es prematuro pensar: “Si faltan más de 10 años, estamos a salvo”. Actualmente existen datos cuyo secreto debe garantizarse durante décadas en el futuro, como la información confidencial del estado, los datos médicos y el diseño de infraestructura a largo plazo.

Lo que preocupa aquí es el método de ataque “Store Now, Decrypt Later” (Almacenar ahora, descifrar después) . Estados u organizaciones malintencionadas interceptan todos los datos de comunicaciones cifrados actualmente con RSA o ECC (Criptografía de curva elíptica) y los guardan en sistemas de almacenamiento. Luego, dentro de 10 o 20 años, en el momento en que se complete una poderosa computadora cuántica, utilizarán el algoritmo de Shor para descifrar todos los datos pasados y exponer los secretos.

Para contrarrestar la amenaza de este desfase temporal, el proceso de estandarización de la “Criptografía Post-Cuántica (PQC: Post-Quantum Cryptography)” ha avanzado a un ritmo acelerado, centrado principalmente en el NIST (Instituto Nacional de Estándares y Tecnología de EE. UU.).

PQC es un nuevo algoritmo criptográfico basado en problemas matemáticos que son difíciles de resolver incluso utilizando computadoras cuánticas (es decir, a los que no se puede aplicar el algoritmo de Shor). Los enfoques principales incluyen los siguientes:

Criptografía basada en retículos (Lattice-based cryptography) : Basado en el problema LWE (Learning with Errors), entre otros. Es la corriente principal en la estandarización del NIST (Kyber, Dilithium, etc.).
Criptografía basada en códigos (Code-based cryptography) : Depende de la dificultad del problema de decodificar códigos de corrección de errores.
Criptografía multivariante (Multivariate cryptography) : Depende de la dificultad de resolver sistemas de ecuaciones cuadráticas con múltiples variables.
Firmas basadas en hash (Hash-based signatures) : Firmas digitales que dependen únicamente de la seguridad de la función hash.

Ya se han iniciado las pruebas de implementación y las implementaciones híbridas de PQC en los principales software y plataformas, como Google Chrome y el iMessage de Apple.

Conclusión

Las computadoras cuánticas están pasando de ser el sueño del mundo de la ciencia ficción a un desafío de ingeniería en la realidad. El algoritmo de Shor es un gran logro intelectual de la humanidad que fusiona las matemáticas y la mecánica cuántica, pero al mismo tiempo tiene un “poder destructivo” oculto que puede sacudir los cimientos de nuestra sociedad digital.

El cifrado RSA no quedará inutilizable inmediatamente mañana. Sin embargo, considerando la evolución de la tecnología cuántica y el riesgo de “Store Now, Decrypt Later”, la migración masiva en la historia de la criptografía, que es la transición a PQC, ya ha comenzado. Ahora mismo somos testigos de la primera línea de un cambio de paradigma en la seguridad de la información.

[Análisis completo] Implementando y entendiendo el algoritmo de descifrado más fuerte 'GNFS' en C++

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

【Análisis Completo】Entendiendo el algoritmo de descifrado más fuerte “GNFS” implementándolo en C++

El cifrado “RSA” es la base que sostiene la Internet moderna. Su robustez depende de la creencia matemática de que “factorizar un número compuesto gigante en números primos es virtualmente imposible con las computadoras actuales”.

Sin embargo, la humanidad nunca se rinde. Actualmente, existe el **algoritmo más fuerte y avanzado de la humanidad ** para realizar factorizaciones gigantescas en computadoras clásicas (computadoras normales, no cuánticas). Este es el “General Number Field Sieve (GNFS) o Criba General del Cuerpo de Números”.

En este artículo, publicaremos todo el código de implementación que modela estrictamente la lógica computacional más avanzada de GNFS en C++ (usando enteros de precisión múltiple boost::multiprecision de la biblioteca Boost), y explicaremos a fondo los abismos de la “teoría algebraica de números” detrás de él.

Por favor, disfruten del misterio de las matemáticas y del poder de la ciencia computacional que lo domina, junto con el código fuente.

1. GNFS Framework Lógico de Vanguardia (Código fuente completo)

Primero, aquí está la visión general de la implementación de GNFS en C++ que explicaremos. La criba de cuerpo de números real (como CADO-NFS) es un sistema distribuido masivo de cientos de miles de líneas de código, pero este código diseña y modela las “5 tuberías (fases) esenciales” que componen GNFS en clases, manteniéndolo en una configuración mínima sin perder su 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


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

// Usando enteros de precisión múltiple de Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Criba General del Cuerpo de Números) Framework Lógico de Vanguardia
//
// Este código modela estrictamente las 5 tuberías del GNFS más avanzado utilizado en CADO-NFS, etc.,
// como diseño de clases en C++ (Boost).
// ============================================================================

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

// ============================================================================
// Fase 1: Selección Polinomial (Algoritmo de KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinomio lado algebraico f(x)
 std::vector<cpp_int> g; // Polinomio lado racional g(x) = x - m
 cpp_int m;

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

 // Generación del polinomio inicial basado en expansión en base m (En realidad se usa reducción de bases de retículos LLL más avanzada)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Polynomial Selection (Grado " << degree << ") iniciando..." << std::endl;
 // Expansión simple en base m (grado d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Aproximación simple de m (sin usar funciones de 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] Completo." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Criba de Retículos)
// ============================================================================
// En el GNFS moderno, el estándar de facto no es Line Sieve (Criba Lineal), sino
// la Criba de Retículos q-Especial (Special-q Lattice Sieving) de Franke-Kleinjung y otros.
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] Generando Factor Bases (Límite Racional: " << rational_bound << ", Límite Algebraico: " << algebraic_bound << ")" << std::endl;
 // (Omitido) En realidad realiza generación de primos y filtrado con el símbolo de Legendre, etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving activo..." << std::endl;
 std::vector<Relation> relations;
 // Implementación Mock: La criba de retículos real escanea cientos de GB de espacio de memoria en bloques,
 // mapea pares (a, b) a retículos para cada primo especial q (a = i*q + j*...),
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.

 // Añadiendo una relación dummy para la demo
 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() << " relaciones." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Purga de singletons y mezcla de cliques)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Filtrando Relaciones..." << std::endl;
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 // En realidad, comprime una matriz de cientos de millones de filas a unos pocos millones usando algoritmos como Union-Find.
 std::cout << "[Fase 3] Tamaño de la matriz reducido óptimamente." << std::endl;
 }
};

// ============================================================================
// Fase 4: Álgebra Lineal sobre GF(2) (Método Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // En los entornos de supercomputadoras recientes, se utiliza como vanguardia el método Block Wiedemann
 // (implementación de Coppersmith) que es más adecuado para computación distribuida que el método Block Lanczos.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritmo Block Wiedemann sobre GF(2) iniciando..." << std::endl;
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Lista de dependencias
 // Datos dummy
 dependencies.push_back({0});

 std::cout << "[Fase 4] Encontradas " << dependencies.size() << " dependencias lineales (cuadrados perfectos)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root)
// ============================================================================
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] Computación de Raíz Cuadrada Algebraica..." << std::endl;

 // 1. Cálculo de la raíz cuadrada racional V (operación de enteros simple)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Cálculo de la raíz cuadrada algebraica gamma (Método de Montgomery, etc.)
 // Encuentra el elemento gamma del cuerpo algebraico gigante O_K, y lo mapea al mundo real con el homomorfismo phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Asumiendo que se añadieron columnas de Caracteres Cuadráticos (Quadratic Characters) en la Fase 2 y 4
 // para evitar la obstrucción del grupo de clases de ideales y el 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 << "[ÉXITO] Factor no trivial encontrado: " << factor << std::endl;
 std::cout << " Otro factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FALLO] Solución trivial. Probando la siguiente dependencia..." << std::endl;
 }
 }
};

// ============================================================================
// Pipeline de Ejecución Principal
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Motor General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Número compuesto gigante N que queremos factorizar, ej. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Grado del polinomio (para más de 130 dígitos usualmente se selecciona grado 5 a 6)
 int degree = 6;

 // Inicialización del pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Los límites reales son decenas a cientos de millones
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. Selección Polinomial
 poly_select.select(N);

 // 2. Proceso de Criba (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtrado (Compresión de matriz)
 filter.reduce_matrix(relations);

 // 4. Álgebra Lineal (Búsqueda del espacio nulo sobre GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Cálculo de Raíz Cuadrada Algebraica y 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 SOTA GNFS completado en " << elapsed.count() << " segundos." << std::endl;

 return 0;
}

Entonces, ¿cómo es que este código destruye los muros de la criptografía? Explicaremos los minuciosos algoritmos y las matemáticas avanzadas para cada una de las 5 fases.

2. El objetivo final de GNFS: $X^2 \equiv Y^2 \pmod N$

El objetivo de la mayoría de los algoritmos de factorización gigante moderna, no solo de GNFS, es encontrar un par no trivial $(X, Y)$ que satisfaga la siguiente congruencia:

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

Esta fórmula significa que “los restos al dividir $X^2$ y $Y^2$ por $N$ son iguales”. Reorganizando esto: $X^2 - Y^2 \equiv 0 \pmod N$ En otras palabras, $(X-Y)(X+Y)$ es un múltiplo de $N$.

Si $X \not\equiv \pm Y \pmod N$ (solución no trivial), existirá un “divisor común mayor que 1 y menor que $N$” entre $(X-Y)$ y $N$. Aquí, si usamos el algoritmo de Euclides para calcular $\gcd(X-Y, N)$, podemos encontrar los factores primos de $N$ con mucha facilidad.

Sin embargo, encontrar estos $X$ e $Y$ es como buscar una aguja en un desierto. Por lo tanto, GNFS adopta el ingenioso enfoque de crear dos mundos, el “mundo de los enteros reales” y el “mundo de los cuerpos algebraicos de los polinomios”, y distribuye los cálculos.

3. Fase 1: Selección 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) y expansión en base m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

El primer paso de GNFS es crear un “polinomio mágico” que sirva de puente entre los dos mundos. Para un número gigante $N$, elegimos un entero $m$. Usualmente se elige de tal manera que $m \approx N^{1/d}$ (el código asume un polinomio de grado $d=6$).

Luego, expandimos $N$ en base $m$ y usamos esos coeficientes para construir el polinomio $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 polinomio $f(x)$ tiene una propiedad extremadamente importante: “al sustituir la variable $x$ con $m$, resulta ser exactamente $N$ ($f(m) = N$)”. En otras palabras, $f(m) \equiv 0 \pmod N$. El polinomio en el lado racional se define como $g(x) = x - m$.

Con esto, el “mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$” dominado por la raíz $\alpha$ de $f(x)=0$ y el “mundo normal de los racionales (enteros) $\mathbb{Z}$” quedan firmemente conectados por un “homomorfismo de anillos” (Homomorphism) de $x \to m$.

En herramientas de vanguardia como CADO-NFS, el polinomio “más conveniente $f(x)$” donde los coeficientes no se vuelven extremadamente grandes y es probable que aparezcan primos en pasos posteriores (más fácil que sea liso), se busca durante meses utilizando el algoritmo de KleinJung y el algoritmo de reducción de bases de retículos LLL.

4. Fase 2: Criba de Retículos q-Especial (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // mapea pares (a, b) a retículos para cada primo especial q,
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.
 // ...
 }
};

Una vez preparados ambos mundos, el siguiente paso es buscar “números lisos” (números formados solo por factores primos pequeños) en ambos mundos. Generamos infinitos pares de enteros $(a, b)$ y calculamos los siguientes dos valores:

Valor racional: $a - bm$
Norma algebraica: $b^d f(a/b)$

El propósito de GNFS es recolectar de decenas a cientos de millones de estos “pares donde tanto el valor racional como el algebraico pueden descomponerse completamente en factores primos pequeños (Relation: relaciones)”.

En los primeros GNFS, se utilizaba una “Criba Lineal (Line Sieve)” que alineaba $(a, b)$ en el plano $xy$ y dividía por primos desde un extremo. Sin embargo, esto causaba muchas fallas de caché al acceder a la memoria en todas partes, y tenía la debilidad de ser muy lento.

Por lo tanto, el código de vanguardia actual utiliza un método llamado “Criba de Retículos q-Especial (Special-q Lattice Sieve)”. Se fija un número primo $q$ moderadamente grande y solo se consideran “los pares $(a, b)$ donde el valor algebraico siempre es divisible por $q$”. Dado que estos $(a, b)$ forman un “retículo (Lattice)” en el plano, el tamaño del salto de la dirección calculada es constante y se ajusta perfectamente a las memorias caché L1/L2 de la CPU. Gracias a la introducción de esta criba de retículos, la velocidad de cálculo de GNFS ha mejorado drásticamente.

5. Fase 3: Filtrado (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 }
};

Cientos de millones de relaciones recolectadas durante meses por computadoras de todo el mundo en la Fase 2. Sin embargo, si metemos esto directamente en el siguiente “paso de resolución de ecuaciones simultáneas (cálculo matricial)”, la memoria de la supercomputadora estallará.

Por eso, se realiza un proceso de supercompresión de la matriz llamado Filtering (Filtrado).

Eliminación de Singletons (Singleton removal / Purga de singularidades) Suponga que un primo gigante $p$ aparece “solo 1 vez” entre cientos de millones de relaciones. Dado que nuestro objetivo es “hacer que los exponentes de todos los primos sean pares (múltiplos de 2)”, un primo que aparece solo 1 vez nunca podrá hacerse par. Por lo tanto, las relaciones que contienen ese primo se eliminan instantáneamente (se purgan) por considerarse “basura inútil”. A medida que esto ocurre en cadena, los datos de cientos de millones de filas se reducen rápidamente.
Fusión de Cliques (Clique merging) Además, multiplicar (sumar) relaciones que comparten un número primo específico reduce el número de filas al tiempo que comprime una matriz dispersa en un estado más denso (se utiliza una técnica similar a la búsqueda de cliques en la teoría de grafos).

Con esta optimización, la enorme matriz dispersa se comprime drásticamente a un tamaño computable.

6. Fase 4: Álgebra Lineal sobre 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) {
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.
 }
};

Por fin, el núcleo del rompecabezas. Multiplicamos las relaciones recolectadas para buscar “combinaciones donde los exponentes de los factores primos sean todos números pares”.

Matemáticamente, esto no es más que encontrar un vector solución $x$ (espacio nulo/kernel) usando una matriz gigante $M$ cuyos elementos son “par/impar (es decir, 0 o 1)” de los exponentes de cada primo y un vector $x$ que indica qué relaciones utilizar: $M \cdot x \equiv 0 \pmod 2$

Tenemos que resolver un sistema de ecuaciones de una matriz de tamaño absurdo de millones de filas × millones de columnas. Con el método normal de eliminación de Gauss, la complejidad sería $O(N^3)$, y el cálculo no terminaría hasta el final del universo.

Por lo tanto, la implementación más avanzada utiliza el “Método Block Wiedemann (Bloque Wiedemann)”. Este es un tipo de método del subespacio de Krylov que aprovecha el hecho de que la matriz $M$ es “extremadamente dispersa (casi toda ceros)” y deriva la solución iterando la multiplicación de matriz y vector. A diferencia del antiguo método Block Lanczos, el método Block Wiedemann puede dividir completamente el proceso de cálculo en múltiples grupos, por lo que ejerce un poder abrumador en la computación en nube distribuida moderna y en la computación paralela en supercomputadoras.

7. Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root) y el Colapso de la Criptografía

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Cálculo de la raíz cuadrada racional V
 cpp_int V = 1;

 // 2. Cálculo de la raíz cuadrada algebraica gamma
 cpp_int Y = 1;

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

A través de los cálculos matriciales de la Fase 4, hemos obtenido un “conjunto de relaciones $S$ que al multiplicarse hacen que todos los factores primos tengan potencias pares”. Con esto, podemos construir el “cuadrado” en ambos mundos, el racional y el algebraico.

Para el lado racional, es simplemente una multiplicación de enteros, por lo que calcular la raíz cuadrada $V$ es fácil.

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

Sin embargo, el verdadero infierno reside en el “lado algebraico”. En el mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$, dado que la factorización única de factores primos no es válida, hemos estado calculando usando ideales. Lo único que garantiza el cálculo matricial es que “es el cuadrado de un ideal”, y no se garantiza que sea “el cuadrado de un elemento ($\gamma^2$)”.

Aquí se levantan poderosos muros en la teoría algebraica de números llamados “obstrucción del grupo de clases de ideales” y “obstrucción del grupo de unidades”. Para romper este muro, GNFS utiliza la magia llamada “Caracteres Cuadráticos (Quadratic Characters)”. A la matriz de la Fase 4, se añaden secretamente de antemano columnas de residuos cuadráticos (Símbolo de Legendre) para decenas de ideales primos especiales. Con esto, hay una probabilidad abrumadora de que el conjunto $S$ encontrado evite la obstrucción y forme con éxito el “cuadrado del elemento verdadero $\gamma^2$”.

El proceso de encontrar $\gamma$ (raíz cuadrada algebraica) se calcula utilizando algoritmos muy complejos como el método de Montgomery.

Y por fin, la raíz cuadrada algebraica $\gamma$ es teletransportada al mundo real (sustituyendo $m$ por $x$) mediante el homomorfismo de anillos $\phi$, y obtenemos $Y$. Si ponemos el $V$ del lado racional directamente como $X$, la ecuación absoluta que hemos estado buscando finalmente se completa.

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

Solo queda calcular $\gcd(X-Y, N)$. En el momento en que se ejecuta el proceso de 0.001 segundos y el factor no trivial se imprime en la pantalla, el cifrado RSA, que se jactaba de ser inexpugnable, colapsa por completo.

Conclusión

GNFS no es simplemente una técnica de programación. Es el cristal del intelecto humano que ha dominado el “abismo de las matemáticas puras” como el álgebra abstracta, la teoría de anillos y los grupos de clases de ideales, con la “ingeniería extrema” como la arquitectura distribuida de supercomputadoras y la optimización de cachés.

La información de chat y de tarjetas de crédito que enviamos de manera informal está protegida sobre una defensa matemática tan astronómica.

Esperamos que, a través de este framework de C++, hayan sentido el “romanticismo de las matemáticas y la informática” detrás del algoritmo de descifrado más avanzado.

La verdadera estructura matemática de la Criba General del Cuerpo de Números (GNFS)

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

La verdadera estructura matemática de la Criba General del Cuerpo de Números (GNFS)

El objetivo final de GNFS es encontrar $X, Y$ tales que $X^2 \equiv Y^2 \pmod N$. Para lograr esto, los matemáticos construyeron un puente entre el “mundo real de los números enteros” y el “mundo de los cuerpos algebraicos”. Ese puente es el “homomorfismo”.

Etapa 1: Conectando mundos con el “Homomorfismo” (Homomorphism)

1. Selección de polinomios y definición de raíces

Para un número compuesto gigante $N$, elegimos un entero $m$ y un polinomio $f(x)$ de manera que $f(m) \equiv 0 \pmod N$. (Ejemplo: expandimos $N$ en base $m$, y formamos $f(x)$ a partir de sus coeficientes. Aquí asumimos que $f(x)$ es irreducible sobre el cuerpo de los números racionales $\mathbb{Q}$ (no se puede factorizar más)).

A continuación, definimos una de las “raíces complejas” de la ecuación $f(x) = 0$ como $\alpha$. Naturalmente, $f(\alpha) = 0$. $\alpha$ no es un entero, sino un número complejo (número algebraico) que puede incluir raíces o números imaginarios.

2. Construcción de Anillos (Rings) y Homomorfismos

Aquí preparamos dos “anillos” matemáticos (mundos donde se definen la suma y la multiplicación):

Mundo A: $\mathbb{Z}[\alpha]$ (el anillo de enteros algebraicos que contiene a $\alpha$) Un mundo de números expresados en la forma $a + b\alpha + c\alpha^2 + \dots$.
Mundo B: $\mathbb{Z}/N\mathbb{Z}$ (el anillo de restos módulo $N$) Un mundo de congruencias (módulos) compuesto solo por números enteros del $0$ al $N-1$.

Aquí, definimos el siguiente mapeo (función) $\phi$ del Mundo A al Mundo B: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Este mapeo $\phi$ es una operación mágica que reemplaza exactamente la variable $\alpha$ del Mundo A por el entero $m$ del Mundo B. Este $\phi$ tiene una propiedad extremadamente poderosa llamada “Homomorfismo de Anillos” (Ring Homomorphism). Un homomorfismo es la propiedad de “transportarse a otro mundo sin destruir la estructura de sumas y multiplicaciones”. Es decir, se cumplen las siguientes ecuaciones:

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

Qué significa esto. Si podemos crear un “cuadrado ($\gamma^2$)” de algún elemento complejo $\gamma$ en el “Mundo A (el mundo de $\alpha$)”, al transportarlo al “Mundo B (el mundo de los restos)” con $\phi$, ** la forma del cuadrado $\phi(\gamma)^2$ se conservará perfectamente**.

Etapa 2: El colapso de la factorización prima y el nacimiento del “Ideal” (Ideal)

Queremos recolectar muchos elementos apropiados $(a - b\alpha)$ dentro del Mundo A ($\mathbb{Z}[\alpha]$) y multiplicarlos juntos para crear un “cuadrado perfecto”. Normalmente, factorizaríamos cada $(a - b\alpha)$ en “factores primos” y los combinariamos para que los exponentes de los números primos sean todos pares (resolviéndolo con matrices) para formar un cuadrado.

Sin embargo, aquí nos encontramos con un muro algebraico desesperante. En un mundo de cuerpos algebraicos como $\mathbb{Z}[\alpha]$, se derrumba la “unicidad de la factorización prima” (la idea que nos enseñaron de que cualquier número puede expresarse como el producto de números primos de una sola manera).

(Ejemplo: en cierto mundo de cuerpos algebraicos, $6 = 2 \times 3$, y al mismo tiempo $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, haciendo imposible saber cuáles son los verdaderos primos).

Si la factorización prima no es única, el rompecabezas de “contar el número de primos para hacerlos pares” (la criba) es en principio imposible de ejecutar.

La salvación de Kummer y Dedekind: el “Ideal”

Lo que salvó a las matemáticas de este colapso fue el concepto de “Ideal” (número ideal) creado por los matemáticos del siglo XIX. Al pensar en el “conjunto de múltiplos (ideal)” generado por un elemento en lugar del elemento en sí, volvieron a hacer posible la factorización prima.

En el anillo de enteros de un cuerpo algebraico $\mathcal{O}_K$ (un anillo más completo que contiene a $\mathbb{Z}[\alpha]$), aunque los elementos no puedan ser factorizados de manera única, se ha demostrado que “los ideales siempre pueden ser factorizados de forma única como un producto de ‘ideales primos ($\mathfrak{p}$)’”.

Por lo tanto, en GNFS, no descomponemos el elemento $(a - b\alpha)$ en sí, sino que hacemos la factorización en ideales primos del ideal principal $\langle a - b\alpha \rangle$ que este genera.

Etapa 3: Norma (Norm) y las dos Cribas (Sieves)

Entonces, ¿cómo sabemos en qué ideales primos se descompone el ideal $\langle a - b\alpha \rangle$? Aquí utilizamos una función llamada “Norma” (Norm). La norma es una función que convierte los elementos complejos de los cuerpos algebraicos en “números enteros reales ordinarios $\mathbb{Z}$”.

La norma del elemento $(a - b\alpha)$ se calcula mediante un simple cálculo polinomial $b^d f(a/b)$ (donde $d$ es el grado de $f(x)$).

Por teoremas algebraicos, sabemos que “si la norma de un ideal se descompone completamente en primos pequeños (es un número liso o ‘smooth’), entonces su ideal original también se descompone completamente en ideales primos pequeños”.

Por lo tanto, GNFS calcula simultáneamente lo siguiente para una gran cantidad de pares de enteros $(a, b)$, y recolecta solo los pares donde ambos son “números lisos”:

Criba Racional (Rational Sieve): $a - bm$ (valor en el mundo real)
Criba Algebraica (Algebraic Sieve): $b^d f(a/b)$ (norma en el mundo del cuerpo algebraico)

Recolecta decenas de millones de pares $(a, b)$ donde ambos son lisos, resuelve los datos de factorización prima de los ideales (cuántos ideales primos están incluidos) como una matriz gigante (álgebra lineal sobre GF(2)), y encuentra un conjunto de pares $S$ de manera que “cuando se multiplican, los exponentes de todos los ideales primos se vuelven pares”.

Etapa 4: Dos “Obstáculos” que se interponen y el Grupo de Clases de Ideales

Mediante cálculos de matrices, encontramos que multiplicar todos los ideales de $(a - b\alpha)$ que pertenecen al conjunto $S$ resulta en el cuadrado de cierto ideal $I$.

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

Sin embargo, esto aún no ha terminado. Aquí es donde se encuentra el muro matemático más profundo y difícil de GNFS.

Lo que finalmente queremos no es el “cuadrado de un ideal”, sino el “cuadrado de un elemento ($\gamma^2$)” para sustituirlo en el mapeo $\phi$. El hecho de que se haya convertido en el cuadrado de un ideal no significa que el elemento en sí sea un cuadrado. Aquí existen dos obstáculos matemáticos (Obstructions) formidables.

Obstáculo 1: El muro del Grupo de Clases de Ideales (Ideal Class Group)

El ideal $I$ no es necesariamente un “ideal generado por un solo elemento (ideal principal)”. Es imposible extraer un elemento concreto $\gamma$ de un ideal que no sea principal.

Aquí entra el concepto de “Grupo de Clases de Ideales” (Class Group, $Cl_K$). El grupo de clases de ideales es un grupo que mide “cuántos ideales que no son principales existen en ese mundo del cuerpo algebraico (qué tan destruida está la unicidad de la factorización prima)”. Incluso si $\prod \langle a - b\alpha \rangle$ se convierte en $I^2$, si $I$ no es el elemento identidad (ideal principal) en el grupo de clases de ideales, no podemos retroceder al cuadrado de un elemento.

Obstáculo 2: El muro del Grupo de Unidades (Unit Group)

Supongamos que por suerte $I$ era un ideal principal $\langle \gamma \rangle$. Entonces tenemos que $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Podrías pensar “¡Genial, el elemento también es un cuadrado!”, pero estarías muy equivocado.

Que los ideales (conjuntos de múltiplos) sean iguales no significa que los elementos sean completamente iguales. Siempre ocurre una desviación por una “Unidad” (Unit: un número cuyo inverso multiplicativo también es entero. Por ejemplo, 1 o -1). Es decir, la verdadera igualdad de los elementos es la siguiente:

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

($u$ es un elemento del grupo de unidades $U_K$)

A menos que esta unidad $u$ sea en sí misma un cuadrado (elemento cuadrático) de algo, el lado izquierdo nunca podrá ser un “cuadrado perfecto de un elemento”.

Etapa 5: La magia de Adleman, “Caracteres Cuadráticos” (Quadratic Characters)

Los obstáculos del grupo de clases de ideales y del grupo de unidades. ¿Cómo los superamos? Aquí es donde entra la genial técnica introducida por el criptógrafo Leonard Adleman (la “A” de RSA) y otros: los “Caracteres Cuadráticos” (Quadratic Characters).

Para determinar “si un elemento es un cuadrado perfecto dentro de un cuerpo algebraico”, utilizamos una versión para cuerpos algebraicos del símbolo de Legendre (residuo cuadrático). En la matriz gigante anterior (el rompecabezas para hacer que el número de ideales primos sea par), añadimos en secreto unas cuantas decenas de condiciones (columnas) adicionales para que “los caracteres cuadráticos para algunos ideales primos especiales $\mathfrak{q}$ también sean todos $1$ (pares)”.

Cuando encontramos un conjunto $S$ que incluso satisface estas condiciones adicionales mediante el cálculo de matrices, por los teoremas profundos de la teoría de números algebraicos, se garantiza que “los obstáculos tanto del grupo de clases de ideales como del grupo de unidades desaparecerán naturalmente con una probabilidad abrumadora”.

Con esto, por fin obtenemos la verdadera ecuación.

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

Etapa Final: La fusión de los mundos y el colapso criptográfico

Por fin, todas las piezas del rompecabezas están en su lugar.

[Elementos del Mundo del Cuerpo Algebraico (Mundo A)] $\gamma^2 = \prod (a - b\alpha)$ (De aquí usamos un algoritmo de raíz cuadrada para encontrar $\gamma$)

[Elementos del Mundo Real (Mundo de los Números Racionales)] $V^2 = \prod (a - bm)$ (Como esta es una simple multiplicación de enteros, podemos encontrar la raíz cuadrada $V$ normalmente)

Ahora, es el turno del puente mágico que construimos al principio: el homomorfismo $\phi$. Transportamos el elemento $\gamma$ del Mundo A al Mundo B (el mundo de restos módulo $N$) usando $\phi$ (el mapeo que sustituye $\alpha$ por $m$).

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

Por otro lado, tomamos la $V$ que creamos en el mundo real directamente al mundo de los restos y la llamamos $X$.

$$X = V \pmod N$$

Debido a la propiedad de “conservar estructuras” del homomorfismo, la relación de los cuadrados que se sostenía en el Mundo A se preserva perfectamente en el Mundo B (el mundo módulo $N$). Además, dado que el par original $(a, b)$ fue creado correspondientemente en la forma $a - b\alpha$ y $a - bm$, estas $X$ e $Y$ chocan en el mundo módulo $N$ y producen la siguiente igualdad absoluta:

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

El resto es rezar para que $X$ e $Y$ no sean una solución trivial ($X \equiv \pm Y$), y calcular: $\gcd(X - Y, N)$

Si es una solución no trivial, el algoritmo de Euclides correrá en 0.001 segundos e imprimirá en la pantalla de salida el corazón del cifrado RSA: los primos secretos $p$ y $q$.

Esta es la forma completa de la “Criba General del Cuerpo de Números (GNFS)”, que reúne lo mejor de las matemáticas modernas.

¿Qué es la 'Criba General del Cuerpo de Números (GNFS)', la matemática más fuerte de la humanidad que rompe el cifrado de Internet?

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

¿Qué es la “Criba General del Cuerpo de Números (GNFS)”, las matemáticas más fuertes de la humanidad que rompen el cifrado de Internet?

El Internet que usamos todos los días. Los mensajes de LINE, YouTube, las compras en Amazon, todas las comunicaciones están protegidas por “cifrado”. Actualmente, el representante del cifrado más utilizado en todo el mundo es el “Cifrado RSA”.

La clave de la defensa del cifrado RSA es muy simple. Utiliza la propiedad matemática de que “la factorización de números primos gigantescos no puede ser resuelta ni siquiera por computadoras”. Por ejemplo, si es “15”, se sabe inmediatamente que es “3 × 5”, pero en el momento en que esto se convierte en un “número de 270 dígitos”, incluso reuniendo las supercomputadoras de todo el mundo llevaría cientos de millones de años resolverlo.

Sin embargo, los matemáticos tampoco se han quedado callados. Para romper este cifrado inexpugnable, la humanidad ha creado un algoritmo (procedimiento de cálculo) parecido a la magia llamado “Criba General del Cuerpo de Números (GNFS: General Number Field Sieve)”.

En este artículo, sin usar términos técnicos en absoluto, explicaremos paso a paso y de manera completa el truco por el cual este “algoritmo más fuerte de la humanidad” rompe el cifrado, solo con conocimientos de matemáticas de secundaria (factorización de primos, álgebra, máximo común divisor)!

Capítulo 1: El objetivo de descifrar el código es “la fórmula de tercer año de secundaria”

El mayor ataque especial para enfrentar la factorización de números primos gigantes. Es esta fórmula que se aprende en tercer año de secundaria.

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

Puede que pienses: “¿Eh, se puede romper un cifrado con una fórmula tan básica?”. Sin embargo, esta es precisamente la llave maestra que lo revela todo.

El objetivo principal para romper el cifrado es, para un número gigante $N$, encontrar “números ($X$ e $Y$) cuyo residuo al dividir $X^2$ e $Y^2$ por $N$ sea el mismo”.

¿Por qué se puede descifrar el código si “el residuo es el mismo”?

Supongamos que el “residuo al dividir por $N$” de dos números, $X^2$ e $Y^2$, es el mismo. Que el residuo sea el mismo significa que existe la regla de que la resta “$X^2 - Y^2$” siempre se divide exactamente por $N$ (es un múltiplo de $N$).

Aquí, supongamos que el número gigante $N$ usado en el cifrado está hecho por la multiplicación de dos números primos secretos ($p$ y $q$) ($N = p \times q$).

Al factorizar $X^2 - Y^2$, se convierte en $(X - Y)(X + Y)$. El hecho de que esto sea un múltiplo de $N$ significa que en algún lugar de esta multiplicación están escondidos los números primos secretos $p$ y $q$.

Aquí ocurre un milagro. La probabilidad de que los dos números primos $p$ y $q$ se separen en habitaciones diferentes, "$p$ va a la habitación de $(X - Y)$" y “$q$ va a la habitación de $(X + Y)$”, es matemáticamente del ** 50% (un medio)**.

Con solo el número primo $p$ entrando en la habitación de $(X - Y)$, calculemos el “máximo común divisor (la pieza común más grande)” de $(X - Y)$ y $N$.

Contenido de $(X - Y)$ = $p \times$ algún número
Contenido de $N$ = $p \times q$ ¡La única pieza común es "$p$"!

Es decir, en el momento en que se calcula el máximo común divisor, el número primo oculto $p$ cae, ¡y el cifrado se descifra por completo! (*El máximo común divisor se puede calcular en un instante incluso en un teléfono inteligente si usas el “Algoritmo de Euclides”).

[Breve columna: ¿Por qué al cuadrado? ¿No se puede al cubo o al doble?]

Si es “$2X - 2Y$”, se convierte en $2(X - Y)$ y como solo hay una habitación, no se pueden separar los números primos. Si es “$X^3 - Y^3$”, el tamaño de las habitaciones se desequilibra y el cálculo se vuelve innecesariamente pesado. Para separar los números primos en dos, la opción más eficiente que se divide bellamente en dos habitaciones es “al cuadrado”.

Capítulo 2: ¿Cómo buscar X e Y? “El rompecabezas de recolectar tarjetas de números primos”

Ya sabemos el objetivo. Sin embargo, incluso si buscas al azar “$X^2$ e $Y^2$ que tengan el mismo residuo”, no lo encontrarás hasta que se acabe la vida útil del universo. Por eso, los matemáticos idearon un método genial llamado “el rompecabezas de recolectar tarjetas de números primos”.

Paso 1: Recolectar solo el oro en polvo (números suaves) con un tamiz

Primero, preparamos un número adecuado $Z$, lo elevamos al cuadrado y calculamos el residuo $W$ al dividirlo por $N$. (El mundo del residuo de $Z^2 = W$)

Factorizamos el residuo $W$ resultante. Aquí, solo cuando aparece un "$W$ compuesto solo de números primos pequeños como 2, 3, 5, 7, etc.", guardamos esa fórmula como una “tarjeta ganadora”, y si se mezclan números primos grandes, la tiramos. Es como la tarea de tirar piedras grandes con un tamiz en un río y recolectar solo el polvo de oro.

Paso 2: El rompecabezas de hacer todo “número par”

Por ejemplo, supongamos que se reunieron las siguientes tres tarjetas de polvo de oro:

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

Multipliquemos todo esto. El lado derecho se convierte en $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, y al organizarlo todo junto queda "$2^4 \times 3^2 \times 5^2$".

¡Increíblemente, la cantidad de números primos se ha vuelto “4, 2, 2”, todos en cantidades pares! El hecho de que todos sean cantidades pares significa que si reducimos la cantidad total a la mitad, se convierte en el “cuadrado de algo”. Es decir, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Dado que el lado izquierdo es $(Z_1 \times Z_2 \times Z_3)^2$, ¡con esto finalmente se completa el tan esperado par de “$X^2 = Y^2$” que es $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$!

Dado que a las computadoras se les da muy bien el rompecabezas de calcular si la cantidad de números primos es “par o impar (0 o 1)”, con este método pueden encontrar $X$ e $Y$ a alta velocidad.

Capítulo 3: El muro de la desesperación que se interpone

¡Con esto se puede romper cualquier cifrado!… Eso pensarías, pero surge un gran problema. Si el número $N$ del cifrado tiene hasta “100 dígitos”, se puede resolver con este método (llamado criba cuadrática), pero cuando $N$ se convierte en “200 dígitos, 300 dígitos”, el $W$ que aparece en el medio del cálculo se vuelve demasiado grande.

Cuando los números se vuelven demasiado grandes, de repente dejan de aparecer los “números hechos solo de primos pequeños (polvo de oro)”. Se vuelve más difícil que buscar una lente de contacto en el desierto, y ya no se pueden juntar en absoluto las tarjetas para resolver el rompecabezas.

Aquí finalmente aparece el arma definitiva de la humanidad, la “Criba General del Cuerpo de Números (GNFS)”.

Capítulo 4: La idea más fuerte de la humanidad: Crear “dos mundos”

La idea genial de GNFS es: “Como calculamos solo en el mundo real, los números se vuelven enormes. Entonces, hagamos un ‘mundo oculto’ usando polinomios (expresiones algebraicas) y dividamos el peso del cálculo en dos”.

La magia de las expresiones algebraicas

GNFS convierte un número gigante $N$ en una expresión algebraica usando un número base $m$. Por ejemplo, si $N=100$, usando $m=4$, $100 = 4^3 + 2(4^2) + 4$. Usando la letra $x$, convertimos esto en la expresión (el mundo oculto) $f(x) = x^3 + 2x^2 + x$.

Lo interesante de esta expresión es que tiene la propiedad de que “si sustituyes la letra $x$ por $m$ (4 en el ejemplo anterior), siempre puedes regresar (teletransportarte) al número real $N$”.

Buscar oro en polvo en dos mundos al mismo tiempo

GNFS crea muchos pares de números enteros $(a, b)$ y realiza los siguientes dos cálculos al mismo tiempo:

El mundo real: $a - b \times m$
El mundo algebraico: el valor de calcular $a - b \times x$ con las reglas del álgebra

Al dividir el problema en dos mundos, el tamaño de los números manejados se vuelve drásticamente menor (más ligero). Es la imagen de partir una roca gigante en dos para convertirla en piedras fáciles de manejar.

Luego, con un tamiz (criba), se recolectan solo los pares milagrosos $(a, b)$ que son “tanto en el mundo real como en el mundo algebraico, ‘hechos solo de números primos pequeños (polvo de oro)’”. Este es el origen del nombre “Criba del Cuerpo de Números”.

El momento en que finalmente se rompe el cifrado

Cuando se reúnen decenas de millones de “tarjetas de polvo de oro” de ambos mundos, utilizando los cálculos de matrices gigantes de una supercomputadora, descubrimos las “combinaciones donde la cantidad de números primos se vuelve toda par” que hicimos en el Capítulo 2.

Una vez que se encuentra la combinación,

Sea el número al cuadrado creado en el mundo real $X^2$
Sea la expresión al cuadrado creada en el mundo algebraico $Y(x)^2$

Finalmente, sustituimos $x$ en el $Y(x)$ del mundo algebraico por $m$, para teletransportarlo y unirlo al mundo real. Entonces, como magia matemática, se completa estrictamente el estado en que “el residuo de $X^2$ y $Y^2$ es el mismo”!

El resto es como en el Capítulo 1, si calculamos el máximo común divisor de $X - Y$ y $N$, el inexpugnable cifrado RSA colapsa estruendosamente, y los números primos secretos hacen su aparición.

Conclusión: Las matemáticas no terminan

Es posible que hayas pensado: “¡Genial, con GNFS se puede romper cualquier cifrado!”. Sin embargo, el cifrado RSA tampoco se queda atrás. Lo que se utiliza en el Internet actual es un número gigantesco monstruoso llamado “RSA-2048 (unos 617 dígitos)”.

Aunque GNFS es el algoritmo más fuerte de la humanidad, se dice que incluso para resolver 270 dígitos (RSA-270), llevaría miles o decenas de miles de años incluso conectando las computadoras de todo el mundo. Por ahora, nuestros datos de LINE o bancos están a salvo.

Sin embargo, ¿qué pasaría si apareciera “una magia para encontrar $X$ e $Y$ en un instante sin importar cuán grande sea el número”? En realidad, la existencia más cercana a eso es la “computadora cuántica (Algoritmo de Shor)” actualmente en desarrollo. Usando las propiedades ondulatorias de la mecánica cuántica, se ha demostrado matemáticamente que se puede ignorar el molesto rompecabezas de recolección de tarjetas y encontrar la respuesta en un solo intento.

La interminable batalla de ingenio entre los creadores de cifrados (defensa) y los creadores de algoritmos para romperlos (ataque). Saber que la “factorización de primos” o el “álgebra” que se aprenden en la secundaria son en realidad armas que luchan ferozmente en la vanguardia de la seguridad mundial, ¿no hace que las clases de matemáticas parezcan un poco más interesantes?

¡Podrías ser tú, que estás leyendo este artículo, quien descubra el algoritmo más fuerte del futuro!

(※Este artículo conceptualiza el encanto matemático del criptoanálisis para estudiantes de secundaria. El GNFS real se calcula estrictamente usando matemáticas universitarias avanzadas, como el grupo de clases de ideales de cuerpos algebraicos y homomorfismos)