Criptografía on kenji.blog

【PQC】La visión completa de la criptografía post-cuántica: La criptografía de próxima generación de la era de las computadoras cuánticas

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

Introducción: La “amenaza” de las computadoras cuánticas a la criptografía

En la actualidad, gran parte de nuestras comunicaciones diarias en Internet (como los pagos bancarios en línea, la navegación web (HTTPS), los mensajes en aplicaciones de mensajería, el blockchain y las transacciones de criptomonedas) están protegidas por una tecnología llamada “criptografía de clave pública”. Específicamente, algoritmos como RSA y la criptografía de curva elíptica (ECC) constituyen la base fundamental que sustenta la fiabilidad de nuestra sociedad digital moderna.

Estos sistemas criptográficos basan su seguridad en problemas matemáticos difíciles, como la “factorización de enteros gigantes” y el “problema del logaritmo discreto”, cuya resolución tomaría un tiempo astronómico para las computadoras clásicas actuales (incluyendo las supercomputadoras). Sin embargo, cuando se materialice el rápido progreso reciente y las “computadoras cuánticas” se vuelvan prácticas, esta premisa se verá alterada desde sus cimientos.

En 1994, Peter Shor publicó el “Algoritmo de Shor”, demostrando matemáticamente que una computadora cuántica con suficiente capacidad puede resolver la factorización de enteros y los problemas de logaritmos discretos en muy poco tiempo. Esto significa el riesgo (conocido como Y2Q: Years to Quantum, o el problema Q-Day) de que toda la comunicación cifrada que protege la Internet actual sea descifrada en el futuro.

Aún más grave es la existencia de una técnica de ataque llamada “Cosechar ahora, descifrar después” (Harvest Now, Decrypt Later), en la cual los datos se roban y almacenan hoy para descifrarlos en el futuro cuando la tecnología lo permita. Los datos que requieren mantenerse confidenciales durante décadas, como la información clasificada del estado, la propiedad intelectual corporativa y la información biométrica personal, ya podrían ser objeto de robo con la premisa de ser descifrados en el futuro.

Para hacer frente a esta crisis sin precedentes, criptógrafos e institutos de investigación de todo el mundo están aunando esfuerzos para desarrollar una tecnología criptográfica de próxima generación que pueda mantener la seguridad incluso contra ataques de computadoras cuánticas: la Criptografía Post-Cuántica (PQC: Post-Quantum Cryptography). En este artículo, explicaremos en detalle desde los fundamentos de la PQC hasta cómo funcionan sus principales algoritmos, así como las últimas tendencias de estandarización global impulsadas por el Instituto Nacional de Estándares y Tecnología de los Estados Unidos (NIST).

¿Qué es la Criptografía Post-Cuántica (PQC)?

La Criptografía Post-Cuántica (PQC) es un término general para los algoritmos criptográficos diseñados para funcionar en las computadoras clásicas existentes y, al mismo tiempo, ser resistentes a ataques de las computadoras cuánticas a gran escala que surgirán en el futuro (como el algoritmo de Shor).

A menudo se confunde con tecnologías como la “Criptografía Cuántica” y la “Distribución Cuántica de Claves (QKD)”, pero estos son enfoques completamente diferentes. La Criptografía Cuántica (QKD) es una tecnología basada en hardware que utiliza las leyes de la física cuántica (como la propiedad de que la observación altera el estado) para hacer que las escuchas clandestinas en la ruta de comunicación sean físicamente imposibles. Requiere fibra óptica dedicada y equipo especial, lo que presenta desafíos en términos de costos de implementación y limitaciones de distancia.

Por otro lado, la PQC es una tecnología criptográfica basada en software fundamentada puramente en “matemáticas”. Por lo tanto, puede incorporarse como actualizaciones de software en la infraestructura de Internet existente, servidores, teléfonos inteligentes, navegadores, etc., lo que la hace altamente aplicable en el mundo real. Las empresas de TI y las agencias gubernamentales de todo el mundo consideran urgente reemplazar (migrar) los actuales RSA y ECC por esta PQC.

Los 4 enfoques matemáticos principales que sustentan la PQC

Se han propuesto varios algoritmos de PQC basados en problemas matemáticos difíciles de resolver de manera eficiente incluso con computadoras cuánticas (como los problemas NP-difíciles). Aquí presentamos las 4 categorías principales que dominan actualmente.

Enfoques principales de la Criptografía Post-Cuántica (PQC)

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


graph LR
 PQC[Criptografía Post-Cuántica PQC] --> L[Criptografía basada en retículos Lattice-based]
 PQC --> H[Criptografía basada en hash Hash-based]
 PQC --> M[Criptografía multivariante Multivariate]
 PQC --> C[Criptografía basada en 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. Criptografía basada en retículos (Lattice-based Cryptography)

Actualmente, la criptografía basada en retículos es la más prometedora y predominante en el campo de la PQC. Su seguridad se fundamenta en problemas relacionados con puntos dispuestos regularmente (puntos de retículo) en espacios multidimensionales. Problemas famosos incluyen el “Problema del Vector Más Corto (SVP)” y el “Aprendizaje con Errores (LWE)”.

Resumen del funcionamiento: Imagine innumerables puntos dispuestos como una cuadrícula (retículo) en un espacio de altísima dimensión (cientos a miles de dimensiones). Encontrar un punto de retículo específico es fácil en 2 o 3 dimensiones, pero a cientos de dimensiones, no se ha descubierto un algoritmo eficiente para encontrarlo, ni para computadoras clásicas ni cuánticas. El problema LWE, en particular, aprovecha la propiedad de que “si se agrega intencionalmente un pequeño ‘ruido (error)’ a un sistema de ecuaciones lineales, se vuelve drásticamente más difícil adivinar las variables originales”.

Ventajas:

Aplicable tanto a la encapsulación de claves (KEM) como a firmas digitales.
Velocidad de procesamiento extremadamente rápida (a veces más rápida que RSA y ECC).
Buen equilibrio entre el tamaño de la clave y el tamaño del texto cifrado.

Muchos de los algoritmos actualmente estandarizados por el NIST (como ML-KEM y ML-DSA) utilizan esta criptografía basada en retículos.

2. Criptografía basada en hash (Hash-based Cryptography)

La criptografía basada en hash es un algoritmo PQC especializado en firmas digitales. La base de su seguridad depende únicamente de la resistencia a colisiones y la unidireccionalidad de “funciones hash criptográficas” seguras como SHA-2 y SHA-3.

Resumen del funcionamiento: Comienza con un esquema de firma de un solo uso llamado “Firma de Lamport”. Al agrupar estas firmas utilizando una estructura de datos en forma de árbol llamada “Árbol de Merkle”, se permiten múltiples firmas con un solo par de claves.

Ventajas:

La base de seguridad es extremadamente robusta; hay una fuerte prueba de que “es seguro mientras la función hash sea segura”.
Al depender poco de una estructura matemática, el riesgo de que se descubra un método de descifrado imprevisto es bajo.

Desventajas:

Solo se puede usar para firmas digitales, no para el establecimiento de claves (KEM).
El tamaño de la firma tiende a ser grande.
Existen variantes “con estado” (stateful) y “sin estado” (stateless). Las variantes con estado (como XMSS) requieren una gestión estricta del número de usos de la clave, lo que dificulta su implementación.

NIST ha estandarizado “SLH-DSA (anteriormente SPHINCS+)” como una firma basada en hash sin estado.

3. Criptografía multivariante (Multivariate Cryptography)

La criptografía de polinomios multivariantes basa su seguridad en la dificultad de resolver un sistema de ecuaciones polinómicas cuadráticas simultáneas con múltiples variables (el problema MQ). Se sabe que este problema es NP-difícil.

Resumen del funcionamiento: El remitente crea un texto cifrado (firma) sustituyendo el texto sin formato (o el valor hash) en una compleja ecuación con múltiples variables proporcionada como clave pública. El destinatario legítimo posee “información oculta (una puerta trasera) que transforma la estructura de la ecuación en una forma fácil de resolver” como su clave privada, y la utiliza para descifrar (o verificar la firma).

Ventajas:

El tamaño de la firma es muy pequeño.
La velocidad de verificación de la firma es extremadamente rápida. Adecuado para dispositivos IoT con recursos limitados.

Desventajas:

El tamaño de la clave pública es muy grande (puede ser de decenas a cientos de kilobytes).
En el pasado, algoritmos prominentes (como Rainbow) han sido quebrados por ataques clásicos, lo que dificulta establecer la confianza en su seguridad en comparación con otros métodos.

4. Criptografía basada en códigos (Code-based Cryptography)

La criptografía basada en códigos aplica a la criptografía la teoría de los “códigos de corrección de errores” utilizados para corregir errores en las rutas de comunicación. El “criptosistema McEliece”, propuesto en 1978, es el más famoso y uno de los más antiguos de la PQC.

Resumen del funcionamiento: El remitente codifica el texto sin formato utilizando la clave pública del destinatario (una matriz generadora de un código de corrección de errores con una estructura oculta), agrega un error intencional (ruido) y lo envía. El destinatario elimina el error usando la clave privada y extrae el texto sin formato. El atacante debe corregir el error de un código aparentemente aleatorio sin conocer su estructura, lo que se conoce como el “problema general de decodificación de síndrome”, probado como NP-difícil.

Ventajas:

Tras más de 40 años de estudio exhaustivo, no se han encontrado ataques efectivos, lo que le otorga una altísima confianza en su seguridad.
Procesamiento de cifrado y descifrado rápido.

Desventajas:

El tamaño de la clave pública es gigantesco (puede ser de varios megabytes). Por lo tanto, es difícil de utilizar en entornos con ancho de banda de comunicación o memoria limitados (como en el handshake de TLS).

Últimas tendencias en la estandarización de PQC por parte del NIST

El Instituto Nacional de Estándares y Tecnología de los Estados Unidos (NIST) comenzó en 2016 a solicitar algoritmos criptográficos post-cuánticos de próxima generación en todo el mundo, llevando a cabo evaluaciones rigurosas y múltiples rondas durante varios años.

En 2024, el NIST anunció finalmente los siguientes tres algoritmos como Estándares Federales de Procesamiento de Información (FIPS) oficiales. Esto proporciona una base sólida para que las organizaciones de todo el mundo comiencen a implementarlos en entornos de producción.

Estándares FIPS Promulgados (2024)

FIPS 203: ML-KEM (anteriormente CRYSTALS-Kyber)
- Uso: Mecanismo de encapsulación de claves (KEM) / Cifrado e intercambio de claves
- Tecnología base: Criptografía de retículos (Module-LWE)
- Características: Excelente equilibrio entre tamaño de clave y velocidad. Actuará como el intercambio de claves PQC predeterminado en aplicaciones comunes de Internet, como la comunicación web (TLS) y las aplicaciones de mensajería segura.
FIPS 204: ML-DSA (anteriormente CRYSTALS-Dilithium)
- Uso: Firma digital
- Tecnología base: Criptografía de retículos (Module-LWE)
- Características: El estándar principal para firmas digitales. Permite un procesamiento eficiente y se convertirá en el nuevo estándar para todos los propósitos de firmas electrónicas, como la firma de software y la autenticación de documentos.
FIPS 205: SLH-DSA (anteriormente SPHINCS+)
- Uso: Firma digital
- Tecnología base: Criptografía basada en hash (sin estado)
- Características: Juega un papel crucial al actuar como respaldo en caso de que se descubran vulnerabilidades en la criptografía de retículos en el futuro. Aunque el tamaño de la firma es mayor, es adecuado para aplicaciones que requieren confiabilidad a largo plazo.

En busca de una mayor diversidad

Si bien el NIST ha completado su proceso de estandarización inicial, continúa explorando más algoritmos. Debido a que el estándar está fuertemente sesgado hacia la “criptografía de retículos”, se hace hincapié en asegurar la “Diversidad Criptográfica” (Crypto Diversity). Se están evaluando métodos como la criptografía basada en códigos como estándares de respaldo para el intercambio de claves, lo que fortalecerá aún más la base de la PQC en el futuro.

Escenarios y desafíos en la transición a PQC: La importancia de la “Agilidad Criptográfica”

Con el lanzamiento de las normas oficiales por parte del NIST, agencias gubernamentales, instituciones financieras y empresas tecnológicas de todo el mundo intensificarán su transición (migración) del RSA/ECC existente a PQC. Las pautas de la NSA (Agencia de Seguridad Nacional de EE. UU.) y otros también recomiendan completar esta transición de manera temprana.

Adopción de un enfoque híbrido

Como los algoritmos PQC son nuevos, no han superado la “prueba del tiempo” en comparación con la criptografía clásica. Considerando el riesgo de posibles errores de implementación o el descubrimiento de nuevos métodos de ataque, se recomienda un “enfoque híbrido” durante el período de transición. Esto implica combinar criptografía existente probada (por ejemplo, ECDHE) con la nueva PQC (por ejemplo, ML-KEM) para el intercambio de claves. Actualmente, los principales navegadores y servicios en la nube están avanzando rápidamente en implementaciones de prueba de este método.

Lograr la Agilidad Criptográfica (Crypto-Agility)

Lo que las empresas y los desarrolladores de sistemas deben tener más presente en el futuro es asegurar la “Agilidad Criptográfica” (Crypto-Agility). Es indispensable diseñar una arquitectura flexible que permita reemplazar y actualizar rápidamente los algoritmos criptográficos sin detener el sistema, en caso de que se descubran fallos en los algoritmos en el futuro o surjan nuevos estándares.

El primer y crucial paso para la transición a PQC es la creación de un Inventario Criptográfico (CBOM: Cryptography Bill of Materials), que permita saber exactamente “dónde”, “qué criptografía” y “con qué propósito” se está utilizando dentro de los sistemas de la empresa.

Conclusión: Preparándose para el “Día Q” (Q-Day)

Si bien la evolución de las computadoras cuánticas traerá enormes beneficios a la humanidad, también representa la mayor amenaza para la seguridad criptográfica, que es la columna vertebral de nuestra sociedad digital actual. La Criptografía Post-Cuántica (PQC) ya no es un “tema de investigación en un futuro lejano”. Con el hito de la publicación de los estándares FIPS por parte del NIST, la PQC ha entrado en una fase de “implementación y transición” a gran escala.

Teniendo en cuenta la amenaza de “Cosechar ahora, descifrar después”, migrar a PQC es una prioridad absoluta que todas las organizaciones que manejan datos altamente confidenciales deben abordar “ahora mismo”. Comprendiendo profundamente las tecnologías criptográficas de próxima generación y aumentando la agilidad criptográfica de los sistemas, preparémonos para superar de forma segura la inminente era de las computadoras cuánticas.

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

Principio de Kerckhoffs

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

Principio de Kerckhoffs

¡Hola!

Hoy me gustaría hablar sobre un tema un poco interesante y, de hecho, extremadamente importante: el “Principio de Kerckhoffs”.

Ah, esperen, esperen. Quizás algunos de ustedes piensen: “Nunca he oído hablar del ‘Principio de Kerckhoffs’ y suena demasiado técnico…”. No se preocupen. Este artículo está escrito precisamente para ustedes.

¿Qué significa una “criptografía segura”?

Por ejemplo, imaginen que alguien les dice: “Esta caja fuerte solo puede ser abierta por quienes conocen el método secreto”.

A primera vista, eso parece muy seguro, ¿verdad? Pero, si lo piensan bien, ¿no les da un poco de inquietud?

Algo así como, “¿qué pasa si se descubre ese secreto? ¿Se acabó todo?”.

De hecho, este es el motivo por el cual aparece el Principio de Kerckhoffs.

Pero, ¿qué es el “Principio de Kerckhoffs”?

En términos muy generales, es la idea de que:

“Un sistema criptográfico debe ser seguro incluso si se conoce su funcionamiento.”

Dicho de otra manera: “La seguridad debe depender únicamente de la ‘clave secreta’, ¡y está bien que el método de encriptación en sí sea público!”.

Por el contrario, esto significa que “un sistema donde solo el algoritmo (el funcionamiento) es un secreto, se considera poco confiable”.

“Si el funcionamiento es secreto, es seguro” puede ser un poco peligroso

Una forma de pensar muy común es esta:

“Nadie ha visto el interior de esta aplicación, así que la seguridad está bien.”

Entiendo el sentimiento. Pero, eso es lo mismo que decir “como nadie lo ha visto, no encontrarán los defectos, así que estamos a salvo”.

En realidad, el simple hecho de que “nadie lo haya visto” puede convertirse en un riesgo en sí mismo.

¿Pero por qué es tan importante este principio?

La razón es que, si alguien logra descubrir cómo funciona y puede descifrarlo fácilmente, entonces ese sistema criptográfico ya no sirve.

Para usar una analogía, es como tener una cerradura con un mecanismo muy complejo, pero que resulta que se puede abrir con una llave maestra comprada en una tienda de todo a un dólar.

Lo importante no es decir “estamos seguros porque la llave es secreta”, sino “incluso si mostramos todo el mecanismo, no se puede abrir sin la llave correcta”.

El sentimiento de “¿pero no da un poco de miedo?”

Aquí es donde muchas personas sienten:

“Revelar todo el mecanismo, ¿no da un poco de miedo?”

Esa inquietud es comprensible. Porque es natural pensar: “Si muestro todo lo que hay dentro, ¿no me copiarán o lo usarán con malas intenciones?”.

Pero, ahí es exactamente donde radica el núcleo del Principio de Kerckhoffs. La “fortaleza que no se desmorona incluso al mostrar el interior” es lo que constituye la verdadera seguridad.

Dicho esto, requiere un poco de valor al principio

Si nos ponemos en el lugar de los desarrolladores, “hacer público el funcionamiento = que se vean las debilidades”, y claro, eso da nervios.

Pero piénsenlo un momento.

Un sistema que se muestra de forma transparente y dice “cualquiera puede verificarlo”, al final resulta más confiable.

Es parecido a las relaciones humanas, ¿verdad?

“Las personas que nos aceptan después de mostrarles nuestro verdadero yo” son, al fin y al cabo, las que más tranquilidad nos dan.

En conclusión

El Principio de Kerckhoffs puede sonar un poco teórico, pero su esencia es muy simple.

Se trata simplemente de: “Creemos un sistema que no se rompa sin importar a quién se lo mostremos.”

Más allá de los secretos superficiales, un diseño sólido. En lugar de código que no quieres que nadie vea, código que no te dé vergüenza mostrar.

Ese tipo de “fortaleza” será cada vez más demandado en los tiempos venideros.

¡Gracias por leer!

Hablar de seguridad puede ser un poco difícil, pero tiene partes que se conectan con “las relaciones humanas” o “la sensación de seguridad en la vida diaria”, ¿verdad? Sin presiones, si vamos aprendiendo poco a poco, seguro que traerá cosas buenas.