Criptografía on kenji.blog

Fundamentos e implementación de criptografía utilizando el pequeño teorema de Fermat

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

1. Introducción: El misterio matemático que sustenta la criptografía moderna

En la sociedad digital moderna, especialmente en las comunicaciones a través de Internet, la “criptografía” se ha convertido en una tecnología base indispensable. El hecho de que podamos navegar de forma segura por sitios web a través de HTTPS en nuestros navegadores web, realizar transacciones financieras en la banca en línea e intercambiar mensajes privados en aplicaciones de mensajería, se debe a que detrás funcionan protocolos criptográficos respaldados por teorías matemáticas avanzadas. Entre ellos, la “criptografía de clave pública” desempeña un papel particularmente importante, y su representante principal es el cifrado RSA.

La seguridad y validez de muchos algoritmos criptográficos, incluido el cifrado RSA, dependen en gran medida de un teorema muy hermoso y poderoso descubierto por el matemático francés del siglo XVII Pierre de Fermat. Este es el pequeño teorema de Fermat (Fermat’s Little Theorem). Además, el teorema de Leonhard Euler, que es una generalización de este, también juega un papel decisivo en la teoría criptográfica.

En este artículo, explicaremos exhaustivamente desde los fundamentos cómo el descubrimiento de las matemáticas puras, el pequeño teorema de Fermat, se aplica a la tecnología criptográfica práctica moderna, especialmente a la “prueba de primalidad” y al “cifrado RSA”. Será una guía técnica muy detallada que cubrirá las demostraciones matemáticas, los mecanismos de cifrado y descifrado, y las implementaciones de algoritmos específicos utilizando C++ y Python.

2. Fundamentos de las congruencias y la aritmética modular

Para entender el pequeño teorema de Fermat, primero debemos familiarizarnos con el concepto matemático de la “aritmética modular (congruencias)”. La aritmética modular es un sistema de cálculo que se centra en el “resto” después de dividir por un número fijo (llamado módulo). Dado que es un cálculo similar a la esfera de un reloj (que da una vuelta cada 12 horas), también se le llama “aritmética del reloj”.

Cuando el resto de dividir los enteros $a$ y $b$ por un entero positivo $n$ es igual, se escribe matemáticamente de la siguiente manera:

$$ a \equiv b \pmod n $$

Esto se lee como “$a$ y $b$ son congruentes módulo $n$”. Por ejemplo, el resto de dividir 17 entre 5 es 2, y el resto de dividir 12 entre 5 también es 2. Por lo tanto, se puede escribir de la siguiente manera:

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

En la aritmética modular, las cuatro operaciones aritméticas básicas (suma, resta y multiplicación) se mantienen tal cual.

Adición: Si $a \equiv b \pmod n$ y $c \equiv d \pmod n$, entonces $a + c \equiv b + d \pmod n$
Sustracción: Si $a \equiv b \pmod n$ y $c \equiv d \pmod n$, entonces $a - c \equiv b - d \pmod n$
Multiplicación: Si $a \equiv b \pmod n$ y $c \equiv d \pmod n$, entonces $a \times c \equiv b \times d \pmod n$
Exponenciación: Si $a \equiv b \pmod n$, entonces para cualquier número natural $k$, $a^k \equiv b^k \pmod n$

Sin embargo, hay que tener cuidado con la división. En general, incluso si $a \times c \equiv b \times c \pmod n$, no podemos dividir ambos lados por $c$ y concluir que $a \equiv b \pmod n$. Esto solo es válido cuando $c$ y $n$ son coprimos (su máximo común divisor es 1). Este concepto de “inverso modular” será extremadamente importante en la generación de claves del cifrado RSA, que discutiremos más adelante.

3. Contexto matemático y demostración del pequeño teorema de Fermat

Habiendo cubierto los fundamentos de la aritmética modular, echemos un vistazo al tema principal, el pequeño teorema de Fermat.

3.1 Definición del teorema

El pequeño teorema de Fermat se formula de la siguiente manera:

Pequeño teorema de Fermat (Fermat’s Little Theorem) Sea $p$ un número primo y sea $a$ cualquier número entero que no sea un múltiplo de $p$ (es decir, $a$ y $p$ son coprimos). Entonces, se cumple la siguiente congruencia:
$$ a^{p-1} \equiv 1 \pmod p $$

También es común expresarlo en una forma que se aplica a todos los enteros $a$, eliminando la condición “que $a$ no sea un múltiplo de $p$”. En ese caso, multiplicamos ambos lados por $a$ para obtener lo siguiente:

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

3.2 Confirmación con ejemplos concretos

Confirmemos si el teorema realmente se cumple utilizando números concretos. Sea el número primo $p = 5$. Entonces $p-1 = 4$. Elegimos como $a$ enteros que no sean múltiplos de $p$.

Caso $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ resto $1$. Por lo tanto, $16 \equiv 1 \pmod 5$. (Se cumple)
Caso $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ resto $1$. Por lo tanto, $81 \equiv 1 \pmod 5$. (Se cumple)
Caso $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ resto $1$. Por lo tanto, $256 \equiv 1 \pmod 5$. (Se cumple)

De esta manera, no importa qué $a$ elijas (siempre que no sea un múltiplo de 5), al elevarlo a la cuarta potencia y dividirlo por 5, el resto será siempre 1. Parece magia, pero esto proviene de las hermosas propiedades que poseen los números primos.

3.3 Demostración matemática del teorema

¿Por qué se cumple esto? Aquí presentamos una demostración elegante utilizando conjuntos de clases de residuos.

Consideremos el conjunto $S = \{1, 2, 3, \dots, p-1\}$. Estos son los representantes de los números enteros cuyo resto al dividir por $p$ va de $1$ a $p-1$. Ahora, consideramos un nuevo conjunto $T$ donde multiplicamos cada elemento por un entero $a$ que es coprimo con $p$.

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

Consideremos los restos al dividir cada elemento de este conjunto $T$ por $p$. Sorprendentemente, estos restos coinciden completamente con el conjunto de elementos del conjunto original $S$, aunque el orden pueda cambiar. Porque:

Ningún elemento de $T$ será un múltiplo de $p$ (porque ni $a$ ni los elementos originales son múltiplos de $p$).
No existen dos elementos diferentes en $T$ que sean congruentes módulo $p$. Si supusiéramos que $ia \equiv ja \pmod p$ ($i \neq j$), dado que $a$ y $p$ son coprimos, podríamos dividir por $a$ y obtener $i \equiv j \pmod p$, lo que es una contradicción.

Por lo tanto, el producto de todos los elementos de $S$ y el producto de todos los elementos de $T$ son congruentes módulo $p$.

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

Reorganizando el lado izquierdo, tenemos $p-1$ veces $a$, por lo que:

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

Dado que $(p-1)!$ es coprimo con $p$, podemos dividir ambos lados por $(p-1)!$, y finalmente se deriva el siguiente teorema:

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

Esta es la demostración del pequeño teorema de Fermat.

4. Función totiente de Euler y teorema de Euler

El pequeño teorema de Fermat es un teorema sobre “números primos $p$”, pero fue Leonhard Euler quien generalizó esto a “cualquier entero positivo $n$”. Esta extensión es esencial para entender el cifrado RSA.

4.1 Función totiente de Euler $\phi(n)$

La función totiente de Euler (o función $\phi$ de Euler) $\phi(n)$ es una función que representa “la cantidad de enteros del $1$ al $n$ que son coprimos con $n$”.

En el caso de un número primo $p$, todos los enteros del $1$ al $p-1$ son coprimos con $p$, por lo que $\phi(p) = p - 1$.
Para dos números primos diferentes $p$ y $q$, y su producto $n = p \times q$, $\phi(n)$ se puede calcular con una fórmula muy simple: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Esta propiedad es la lógica fundamental en la generación de claves del cifrado RSA.

4.2 Teorema de Euler

Euler generalizó el pequeño teorema de Fermat de la siguiente manera:

Teorema de Euler (Euler’s Theorem) Para cualquier entero positivo $n$ y un entero $a$ coprimo con $n$, se cumple lo siguiente:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Si $n$ es un número primo $p$, entonces $\phi(p) = p - 1$, por lo que esto se convierte en el pequeño teorema de Fermat mismo ($a^{p-1} \equiv 1 \pmod p$). En otras palabras, el pequeño teorema de Fermat no es más que un caso especial del teorema de Euler.

5. Encontrar números primos gigantes: Prueba de primalidad de Fermat

En las tecnologías criptográficas (como el cifrado RSA y el intercambio de claves de Diffie-Hellman), es necesario encontrar rápidamente “números primos gigantes” de cientos de dígitos. Sin embargo, para determinar si un número gigantesco $N$ es primo, el método de “división por tentativa” (intentar dividir por todos los números desde $2$ hasta $\sqrt{N}$) tomaría un tiempo comparable a la edad del universo.

Ahí es donde entra en juego la prueba de primalidad de Fermat (Fermat Primality Test), un “método de prueba de primalidad probabilística” que aprovecha el pequeño teorema de Fermat a la inversa.

5.1 ¿Qué es un método de prueba de primalidad probabilística?

Según el pequeño teorema de Fermat, si $p$ es primo, para cualquier $a$ ($1 < a < p$), se debe cumplir obligatoriamente $a^{p-1} \equiv 1 \pmod p$. Tomando la contrapuesta de esto, podemos decir que “si para algún $a$, $a^{p-1} \not\equiv 1 \pmod p$, entonces $p$ definitivamente no es primo (es un número compuesto)”.

Por lo tanto, si queremos determinar si $N$ es primo, elegimos varios $a$ al azar, calculamos $a^{N-1} \pmod N$ y verificamos si el resultado es $1$. Si se obtiene una respuesta distinta de $1$ incluso una vez, se confirma que $N$ es un número compuesto. Si el resultado es $1$ repetidas veces, podemos juzgar con alta probabilidad que $N$ es “probablemente un número primo”.

5.2 Explicación del algoritmo y diagrama de flujo

El algoritmo de la prueba de Fermat es el siguiente:

flowchart TD Start["Inicio"] --> Input["Ingresar el número p a probar y la cantidad de pruebas k"] Input --> LoopStart["Bucle desde i = 0 hasta k-1"] LoopStart --> Condition{"¿i < k?"} Condition -- "Sí" --> RandomA["Elegir un entero aleatorio a en el rango 1 < a < p-1"] RandomA --> Calc["Calcular la exponenciación modular a^(p-1) mod p"] Calc --> CheckPrime{"¿El resultado es 1?"} CheckPrime -- "No" --> ReturnComposite["p es un número compuesto (confirmado)"] CheckPrime -- "Sí" --> Increment["Incrementar i"] Increment --> Condition Condition -- "No" --> ReturnPrime["p es probablemente un número primo (probabilístico)"] ReturnComposite --> End["Fin"] ReturnPrime --> End

5.3 La trampa de los números de Carmichael (pseudoprimos)

La prueba de Fermat es muy rápida, pero tiene un defecto importante. Existen números diabólicos que, a pesar de ser números compuestos, cumplen que $a^{N-1} \equiv 1 \pmod N$ para todos los $a$. Estos se denominan números de Carmichael (Carmichael numbers). El número de Carmichael más pequeño es $561$ ($3 \times 11 \times 17$).

Debido a la existencia de los números de Carmichael, una prueba de Fermat pura por sí sola no puede determinar la primalidad de manera absoluta. Por lo tanto, en los sistemas criptográficos reales (como OpenSSL), se utiliza de forma estándar la prueba de primalidad de Miller-Rabin, que es una versión mejorada de la prueba de Fermat. La prueba de Miller-Rabin puede desenmascarar los números de Carmichael, reduciendo la probabilidad de falsos positivos prácticamente a cero.

5.4 Exponenciación modular rápida (método de cuadratura sucesiva)

En el algoritmo de la prueba de primalidad, es necesario calcular $a^{N-1} \pmod N$, pero si $N$ es gigantesco, $a^{N-1}$ se convierte en un número con una cantidad astronómica de dígitos que no cabe en la memoria de la computadora. Esto se resuelve mediante el método de cuadratura sucesiva (Exponentiation by Squaring) o exponenciación modular. Al tomar el módulo (mod N) en cada paso del cálculo, el valor siempre se mantiene menor que $N$, permitiendo que el cálculo sea extremadamente rápido (complejidad temporal $O(\log N)$).

6. Implementación de la prueba de primalidad y la exponenciación modular

Ahora, intentemos implementar la prueba de primalidad de Fermat y el método de cuadratura sucesiva en C++ y Python.

6.1 Implementación en C++

En C++, los tipos enteros estándar son propensos al desbordamiento (overflow), por lo que se requiere una biblioteca de enteros de precisión múltiple (como GMP) para manejar números enormes. Sin embargo, aquí mostraremos una implementación dentro del rango de enteros de 64 bits (unsigned long long) para comprender el algoritmo.

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


#include <iostream>
#include <random>

using namespace std;

// Exponenciación modular rápida (a^b mod m) - Método de cuadratura sucesiva
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Si el bit menos significativo de b es 1, multiplicar a al resultado
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Extensión a 128 bits para evitar desbordamiento
 }
 // Elevar a al cuadrado
 a = (__int128)a * a % m;
 // Desplazamiento a la derecha de b (dividir a la mitad)
 b /= 2;
 }
 return result;
}

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

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

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Si a^(p-1) mod p no es 1, es un número compuesto
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Probablemente primo
}

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

6.2 Implementación en Python

Los tipos enteros estándar de Python soportan enteros de precisión múltiple, por lo que no hay necesidad de preocuparse por el desbordamiento de dígitos. Además, la función incorporada de Python pow(a, b, m) utiliza internamente el método de cuadratura sucesiva, por lo que es extremadamente rápida.

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


import random

def fermat_is_prime(p, iterations=5):
 """
 Prueba de primalidad probabilística usando el test de Fermat
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Elegir un número aleatorio a entre 2 y p-2
 a = random.randint(2, p - 2)
 # Calcular a^(p-1) mod p. La función pow incorporada es rápida.
 if pow(a, p - 1, p) != 1:
 return False # Compuesto confirmado

 return True # Probablemente primo

# Prueba
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} es probablemente primo.")
else:
 print(f"{number_to_test} es un número compuesto.")

7. Aplicación al cifrado RSA: Donde Fermat y Euler convergen

La mayor aplicación del pequeño teorema de Fermat (y del teorema de Euler) es el cifrado RSA, desarrollado en 1977 por Rivest, Shamir y Adleman. El cifrado RSA es un sistema revolucionario de “criptografía de clave pública”, que realiza un mecanismo en el que la clave para cifrar (clave pública) se publica en todo el mundo, mientras que la clave para descifrar (clave privada) es conocida únicamente por el propio receptor.

Esta asimetría se basa en la seguridad computacional de que “la factorización en números primos de números compuestos enormes es extremadamente difícil”.

7.1 Funcionamiento del cifrado RSA (generación de claves, cifrado, descifrado)

Veamos el flujo de comunicación general del cifrado RSA con un diagrama de secuencia de Mermaid.

sequenceDiagram participant Alice["Alice (Receptora)"] participant Bob["Bob (Remitente)"] Alice->>Alice: "Generar primos gigantes p, q" Alice->>Alice: "Calcular N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Calcular clave pública e y clave privada d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Enviar clave pública (N, e)" Note over Bob: "Preparar texto plano M (M < N)" Bob->>Bob: "Calcular texto cifrado C = M^e mod N" Bob->>Alice: "Enviar texto cifrado C" Alice->>Alice: "Calcular texto plano M = C^d mod N y descifrar"

A continuación, se explican los pasos matemáticos detallados.

Paso 1: Generación de claves (tarea de la receptora Alice)

Generar aleatoriamente dos números primos enormes, $p$ y $q$ (aquí se utiliza el método de prueba de primalidad mencionado anteriormente).
Calcular su producto $N = p \times q$. Este $N$ se hace público.
Utilizando la función totiente de Euler, calcular $\phi(N) = (p-1)(q-1)$.
Elegir un número entero $e$ (exponente público) que sea coprimo con $\phi(N)$ (a menudo se usa $e = 65537$).
Calcular el inverso modular $d$ (exponente privado) de $e$. Es decir, encontrar $d$ que cumpla lo siguiente: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Para este cálculo, se utiliza el algoritmo de Euclides extendido.

Con esto, la clave pública es $(N, e)$ y la clave privada es $(N, d)$. (Se deben descartar inmediatamente u ocultar estrictamente $p, q$ y $\phi(N)$).

Paso 2: Cifrado (tarea del remitente Bob)

Supongamos que Bob quiere enviar el mensaje $M$ a Alice ($M$ es el texto convertido en valor numérico, donde $0 \le M < N$). Bob utiliza la clave pública de Alice $(N, e)$ para realizar el siguiente cálculo y crear el texto cifrado $C$.

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

Este $C$ se transmite a Alice a través de la red.

Paso 3: Descifrado (tarea de la receptora Alice)

Alice, habiendo recibido el texto cifrado $C$, utiliza la clave privada $d$ que solo ella conoce para realizar el siguiente cálculo.

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

Sorprendentemente, este resultado del cálculo $M'$ coincide exactamente con el mensaje original $M$.

7.2 ¿Por qué se puede descifrar? (Demostración matemática)

Aquí es donde el pequeño teorema de Fermat (teorema de Euler) demuestra su verdadero valor. ¿Por qué $C^d \pmod N$ vuelve a $M$?

Vamos a expandir la fórmula de descifrado. Dado que $C \equiv M^e \pmod N$,

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

En el paso de generación de claves, elegimos $d$ de manera que $e \cdot d \equiv 1 \pmod{\phi(N)}$. Esto significa que existe un cierto entero $k$ tal que se puede escribir como sigue:

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

Sustituimos esto en la ecuación anterior.

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

Aquí es donde entra el teorema de Euler ($M^{\phi(N)} \equiv 1 \pmod N$). (※Estrictamente hablando, $M$ y $N$ necesitan ser coprimos, pero en RSA la probabilidad de que $M$ y $N$ no sean coprimos es astronómicamente baja, y además, se puede demostrar que es válido incluso si no son coprimos utilizando el teorema chino del resto).

Aplicando el teorema de Euler, dado que $M^{\phi(N)} \equiv 1$,

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

¡$M$ ha sido restaurado magníficamente! Las propiedades de los números descubiertas por Fermat y Euler hace cientos de años garantizan perfectamente la confidencialidad de las comunicaciones digitales modernas.

8. Implementación de juguete del cifrado RSA (Python)

Como es difícil captar la idea solo con teoría, intentemos implementar el proceso de generación de claves, cifrado y descifrado del cifrado RSA usando Python. Esta es una “implementación de juguete” con fines educativos, pero las matemáticas utilizadas son exactamente las mismas que las reales.

También incluiremos en la implementación el “algoritmo de Euclides extendido” para encontrar el inverso modular $d$.

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


import random

# Encontrar el máximo común divisor
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

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

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('El inverso modular no existe')
 else:
 return x % phi

# Función de generación de números primos (versión simple: genera primos pequeños)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Determinación simple en lugar de la prueba de Fermat mencionada anteriormente
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Generación de par de claves RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Asegurarse de que p y q no sean iguales
 while p == q:
 q = generate_prime(bits)

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

 # A menudo se usan primos como 65537 para e, pero aquí se elige al azar
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Cálculo de la clave privada d
 d = mod_inverse(e, phi)

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

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

def decrypt(sk, ciphertext):
 d, n = sk
 # Calcular cipher^d mod n, y volver al carácter
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Ejemplo de ejecución
if __name__ == '__main__':
 print("--- Implementación de juguete de cifrado RSA ---")
 public_key, private_key = generate_keypair(bits=12) # Uso de primos de 12 bits

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

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

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

 # Descifrado
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Mensaje descifrado: {decrypted_msg}")

Al ejecutar este código, puedes confirmar cómo una matriz de caracteres se convierte en una matriz de números desconocidos (texto cifrado), y cómo la clave privada la restaura magníficamente a la cadena original.

9. Conclusión: La intersección entre la belleza matemática y la utilidad práctica

En el siglo XVII, cuando Pierre de Fermat descubrió este “pequeño teorema”, nadie pensaba que sería útil para nada. El propio Fermat investigó la teoría de números por pura curiosidad matemática.

Sin embargo, unos 300 años más tarde, en la década de 1970, en los albores de las redes informáticas, el teorema de Fermat hizo un regreso dramático como una tecnología criptográfica indispensable para establecer protocolos de comunicación seguros. La tecnología de prueba de primalidad basada en el pequeño teorema de Fermat, y el cifrado RSA basado en el teorema de Euler, sostienen literalmente la infraestructura moderna de Internet.

Los mensajes de WhatsApp que enviamos de forma casual todos los días, y nuestras compras en Amazon, todo está bailando sobre esta fórmula simple y hermosa: $a^{p-1} \equiv 1 \pmod p$. El pequeño teorema de Fermat nos enseña que por muy abstractas que sean las matemáticas, siempre llegará un momento en el que sean útiles para la humanidad.

Al estudiar programación o teoría criptográfica, comprender la estructura matemática que sirve como base será una gran herramienta para comprender profundamente el comportamiento de las bibliotecas que se proporcionan como cajas negras y para diseñar sistemas más seguros.

【Explicación matemática】Explicando el mecanismo del cifrado RSA para que hasta un estudiante de secundaria pueda entenderlo

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

Una de las tecnologías que sustenta la seguridad de la sociedad de internet desde su base es el “cifrado RSA”. Gran parte de las comunicaciones que usamos casualmente todos los días, como los pagos con tarjeta de crédito en compras en línea, los intercambios de mensajes en redes sociales con amigos y el envío o recepción de información confidencial de las empresas, están protegidas por este cifrado RSA o sus tecnologías sucesoras.

Sin embargo, al escuchar “cifrado”, podrías imaginar máquinas de cifrado complejas como las que aparecen en las películas de espías, o matemáticas súper avanzadas que solo un puñado de genios puede entender. Es cierto que la teoría criptográfica moderna se basa en matemáticas avanzadas, pero el mecanismo fundamental del cifrado RSA se puede entender perfectamente si tienes conocimientos de las matemáticas que se aprenden en la escuela secundaria (propiedades de los números enteros, números primos, congruencias, etc.).

En este artículo, tomando como punto de partida los conocimientos de matemáticas de secundaria, explicaremos exhaustivamente y paso a paso en qué principios matemáticos opera el cifrado RSA y por qué es tan difícil de descifrar. Explicaremos cuidadosamente con ejemplos concretos para que incluso aquellos a los que no se les dan muy bien las matemáticas puedan entenderlo.

1. Cifrado de clave simétrica y cifrado de clave pública

Antes de entrar en el mecanismo matemático del cifrado RSA, primero organicemos el concepto básico de la criptografía. Los sistemas criptográficos se dividen a grandes rasgos en dos tipos: “cifrado de clave simétrica” y “cifrado de clave pública”.

1.1 Limitaciones del cifrado de clave simétrica

Muchos de los cifrados que se han utilizado desde la antigüedad son lo que se llama “sistemas de cifrado de clave simétrica”. Este es un sistema donde se usa la misma clave para “cifrar (convertir un mensaje en un texto cifrado secreto)” y para “descifrar (devolver el texto cifrado al mensaje original)”.

Por ejemplo, supongamos que Alice envía una carta secreta a Bob. Alice pone la carta en una caja y la cierra usando un candado (clave simétrica). Para que Bob pueda abrir esa caja, necesita tener la misma clave que usó Alice.

Este sistema tiene un gran problema: “El problema de la distribución de claves”. Cuando Alice y Bob, que están muy lejos, se comunican por primera vez, ¿cómo pueden compartir la clave sin que sea interceptada? Si la clave es robada por un tercero mientras se envía por correo, todas las comunicaciones cifradas posteriores quedarán completamente expuestas.

1.2 Un invento revolucionario: “Sistema de cifrado de clave pública”

Para resolver este problema de distribución de claves, se ideó el “sistema de cifrado de clave pública”. El cifrado RSA también es un tipo de este sistema.

En el sistema de cifrado de clave pública, se utilizan dos claves diferentes: “una clave para cifrar (clave pública)” y “una clave para descifrar (clave privada)”.

El receptor, Bob, crea un par de “clave pública” y “clave privada”.
Bob publica la “clave pública” al mundo entero (no importa quién la obtenga).
La remitente, Alice, cifra el mensaje usando la “clave pública” de Bob y lo envía.
El mensaje cifrado solo puede ser descifrado con la “clave privada” que únicamente Bob posee.

Usando la analogía del candado, Bob fabrica muchos “candados abiertos (clave pública)” y los esparce por todo el mundo. Alice pone el mensaje dirigido a Bob en una caja y la cierra usando uno de los candados que encontró de Bob. Una vez que el candado se cierra, solo se puede abrir con la “llave maestra (clave privada)” que tiene Bob. Aunque alguien robe la caja en el camino, no podrá abrirla sin la llave maestra.

graph TD A["Alice (Remitente)"] --> B["Texto plano (Mensaje)"] B --> C["Proceso de cifrado"] D["Clave pública de Bob (Disponible para cualquiera)"] --> C C --> E["Enviado a través de internet: Texto cifrado"] E --> F["Proceso de descifrado"] G["Clave privada de Bob (Solo Bob la tiene)"] --> F F --> H["Texto plano restaurado (Mensaje)"] H --> I["Bob (Receptor)"]

Para hacer realidad este revolucionario sistema, se necesita una especie de “función unidireccional (un rompecabezas matemático de un solo sentido)” que signifique “es fácil cifrar con la clave pública, pero es absolutamente imposible descifrar sin la clave privada”. Las piezas del rompecabezas elegidas para esto fueron los conocidos “números primos”.

2. Fundamento matemático 1 que sustenta el cifrado RSA: Números primos y factorización en números primos

La seguridad del cifrado RSA se basa en el hecho matemático de que “la factorización en números primos de números gigantescos es extremadamente difícil”.

2.1 Qué son los números primos

Los números primos son “números naturales mayores que 1 que solo se pueden dividir exactamente por 1 y por sí mismos”. Ejemplo: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Los números primos son como los “átomos” de todos los números enteros. Cualquier número natural se puede descomponer en forma de multiplicación de números primos. A esto se le llama factorización en números primos. Por ejemplo, ignorando el orden, se sabe que cualquier número se puede factorizar de una sola manera, como $60 = 2^2 \times 3 \times 5$; esto se conoce como el “Teorema fundamental de la aritmética”.

2.2 La dificultad de la factorización en números primos (Función unidireccional)

Lo importante aquí es la asimetría: “multiplicar es fácil, pero factorizar es difícil”.

Por ejemplo, intenta calcular mentalmente la siguiente multiplicación de dos números primos: $11 \times 13 = ?$ Es fácil, ¿verdad? La respuesta es $143$.

Ahora, ¿qué tal el siguiente número? Factoriza $323$ en números primos. ¿Cómo te va? Seguramente te tomará un poco de tiempo. (La respuesta es $17 \times 19$).

Si los números son pequeños, un humano puede calcularlos de alguna manera, pero cuando los números se vuelven grandes, calcularlos se vuelve explosivamente difícil, incluso usando computadoras. En el cifrado RSA dominante actual, se utiliza un número $N = p \times q$ que es el resultado de multiplicar dos números primos colosales de 2048 bits (aproximadamente 600 dígitos en base 10), $p$ y $q$.

Cuando se dan dos números primos gigantes $p$ y $q$, calcular $N$ toma solo un instante (menos de un milisegundo) para una computadora. Sin embargo, a la inversa, si solo se da $N$, encontrar los $p$ y $q$ originales tomaría tanto tiempo que ni siquiera la supercomputadora más rápida actual podría resolverlo en billones de años.

Esta “asimetría del cálculo (el camino de ida es fácil, el de vuelta es difícil)” se convierte en la base que crea la relación entre la clave pública y la clave privada.

3. Fundamento matemático 2 que sustenta el cifrado RSA: Congruencias (Aritmética modular)

Los cálculos del cifrado RSA no se realizan en el mundo de las sumas y multiplicaciones habituales donde los números crecen infinitamente, sino en el mundo del “resto” después de dividir por un número determinado. A esto se le llama congruencia (aritmética modular).

3.1 Las matemáticas del reloj

La aritmética modular a menudo se compara con las “matemáticas del reloj”. Si ahora son las 10, ¿qué hora será 5 horas después? $10 + 5 = 15$ en punto, pero en un reloj normal de 12 horas, respondemos “las 3”. Esto se debe a que el resto de dividir 15 entre 12 es 3.

En el mundo de las matemáticas, esto se escribe de la siguiente manera:

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

Se lee como “15 es congruente con 3 módulo 12 (el resto de dividirlos por 12 es igual)”.

3.2 Propiedades básicas de las congruencias

Las congruencias tienen propiedades muy útiles y similares a las ecuaciones ($=$). Sea $N$ el módulo (número divisor). Cuando $a \equiv b \pmod N$ y $c \equiv d \pmod N$, se cumple lo siguiente:

Suma: $a + c \equiv b + d \pmod N$
Resta: $a - c \equiv b - d \pmod N$
Multiplicación: $a \times c \equiv b \times d \pmod N$
Potenciación: $a^k \equiv b^k \pmod N$ ($k$ es un número natural)

Especialmente importante es la propiedad de la “potenciación”. Esto significa que “el resto de una potencia es igual a la potencia del resto”. Por ejemplo, supongamos que queremos encontrar el resto de dividir $7^{100}$ entre $5$. Sería muy difícil multiplicar $7$ cien veces y luego dividirlo entre $5$, pero usando la propiedad de las congruencias, como $7 \equiv 2 \pmod 5$, entonces $7^{100} \equiv 2^{100} \pmod 5$, lo que simplifica drásticamente el cálculo. Dado que en el mundo de la criptografía se manejan potencias de números muy grandes, esta propiedad es indispensable.

4. Fundamento matemático 3 que sustenta el cifrado RSA: La función de Euler y el Teorema de Euler

A partir de aquí entran las matemáticas mágicas que son el núcleo del cifrado RSA. Aparece el “Teorema de Euler”, que es una generalización del “Pequeño teorema de Fermat”.

4.1 La función indicatriz de Euler $\phi(N)$

La función indicatriz de Euler (función $\phi$) es una función que, para un número natural dado $N$, devuelve “la cantidad de números naturales desde el 1 hasta $N$ que son coprimos (su máximo común divisor es 1) con $N$”.

Veamos algunos ejemplos:

$\phi(5)$: Entre 1, 2, 3, 4, 5, los que son coprimos con 5 son 1, 2, 3 y 4 (son 4 números). Por lo tanto, $\phi(5) = 4$.
$\phi(6)$: Entre 1, 2, 3, 4, 5, 6, los que son coprimos con 6 son 1 y 5 (son 2 números). Por lo tanto, $\phi(6) = 2$.

[Propiedad especial en el caso de números primos] Si $p$ es un número primo, todos los números del 1 al $p-1$ son coprimos con $p$. Por lo tanto,

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

[Propiedad especial en el caso del producto de números primos] Para dos números primos diferentes $p$ y $q$, si definimos $N = p \times q$, $\phi(N)$ se puede calcular fácilmente de la siguiente manera:

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

Esta propiedad funciona como la “puerta trasera secreta (trapdoor)” del cifrado RSA. Una persona (el creador de la clave) que conoce $p$ y $q$ puede calcular $\phi(N)$ en un instante, pero un tercero que solo conoce $N$ no puede encontrar $\phi(N)$ a menos que factorice $N$ en números primos.

4.2 El Teorema de Euler

Leonhard Euler demostró un teorema hermoso usando esta $\phi(N)$.

Teorema de Euler: Cuando dos enteros $a$ y $N$ son coprimos, se cumple la siguiente congruencia:

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

Esta es una propiedad sorprendente que dice que “si multiplicas un número $a$ por sí mismo $\phi(N)$ veces y lo divides por $N$, el resto siempre será $1$”. (Cuando $N$ es un número primo $p$, se convierte en $a^{p-1} \equiv 1 \pmod p$, lo que se conoce como el Pequeño teorema de Fermat).

Modifiquemos este teorema de Euler. Multiplicamos ambos lados por $a$ una vez más:

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

Además, para cualquier entero $k$, dado que $a^{k \cdot \phi(N)}$ también se convierte en $1^k = 1$, se cumple la siguiente ecuación:

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

¡Esta fórmula es precisamente el principio fundamental que hace posible la magia del cifrado RSA de “volver al estado original al cifrar y descifrar”!

5. El algoritmo del cifrado RSA: Pasos de generación de claves, cifrado y descifrado

Ahora que tenemos los conocimientos básicos, veamos los pasos específicos del cifrado RSA. El cifrado RSA se divide a grandes rasgos en tres fases: “1. Generación de claves”, “2. Cifrado” y “3. Descifrado”.

flowchart TD A1["1. Elegir números primos p, q"] --> A2["Calcular N = p × q"] A1 --> A3["Calcular φ(N) = (p-1)(q-1)"] A3 --> A4["Elegir e que sea coprimo con φ(N)"] A3 --> A5["Calcular d tal que e × d ≡ 1 (mod φ(N))"] A2 --> A6["Clave pública (N, e)"] A4 --> A6 A5 --> A7["Clave privada d"] B1["2. Mensaje en texto plano M"] --> B2["Calcular C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Enviar texto cifrado C"] B3 --> C1["3. Texto cifrado recibido C"] C1 --> C2["Calcular M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Obtener mensaje en texto plano original M"]

5.1 Generación de claves (Key Generation)

El receptor, Bob, genera su propia “clave pública” y “clave privada”.

Selección de números primos: Elige dos números primos grandes $p$ y $q$ al azar.
Cálculo del módulo $N$: Calcula $N = p \times q$. Este $N$ se hará público.
Cálculo de $\phi(N)$: Calcula la función de Euler $\phi(N) = (p - 1)(q - 1)$. Este es un número secreto solo de Bob.
Selección de la clave pública $e$: Elige un entero $e$ tal que $1 < e < \phi(N)$ y que sea coprimo con $\phi(N)$.
Cálculo de la clave privada $d$: Encuentra un entero $d$ que cumpla la siguiente condición: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ En otras palabras, es “un número $d$ tal que al dividir $e \times d$ entre $\phi(N)$, el resto es $1$”.

Con esto, la preparación de las claves está completa.

Clave pública: El par $(N, e)$. Se hace pública a todo el mundo.
Clave privada: $d$. No se le dice absolutamente a nadie.

5.2 Cifrado (Encryption)

Supongamos que Alice quiere enviarle a Bob el mensaje secreto $M$. (Donde $M$ es el texto convertido en un número y $0 \le M < N$). Alice calcula lo siguiente usando la clave pública de Bob $(N, e)$:

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

Calcula “el resto $C$ de dividir el mensaje $M$ elevado a la potencia de $e$ entre $N$”. Este $C$ es el texto cifrado.

5.3 Descifrado (Decryption)

Bob recibe el texto cifrado $C$. Bob calcula lo siguiente usando la clave privada $d$:

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

¡Al calcular “el resto de dividir el texto cifrado $C$ elevado a la potencia de $d$ entre $N$”, mágicamente se restaura el mensaje original $M$!

6. ¿Por qué el descifrado devuelve el texto original? (Demostración matemática)

Quizás te preguntes, “¿Por qué al elevar $C$ a la potencia de $d$ se vuelve al $M$ original?”. Aquí es donde el “Teorema de Euler” mencionado antes demuestra su poder.

Sustituyamos la fórmula de cifrado $C = M^e$ en la fórmula de cálculo de descifrado $C^d \pmod N$.

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

Aquí, recuerda el paso 5 de la generación de claves. Cuando Bob creó $d$, lo eligió para que $e \times d \equiv 1 \pmod{\phi(N)}$. Esto significa que “$ed$ es un múltiplo de $\phi(N)$ más $1$”. Usando un número entero $k$, se puede escribir de la siguiente manera:

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

Sustituimos esto en la parte del exponente y lo descomponemos usando las leyes de los exponentes:

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

Aquí, asumiendo que el mensaje $M$ y $N$ son coprimos, según el Teorema de Euler, $M^{\phi(N)} \equiv 1 \pmod N$.

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

Por lo tanto, la siguiente fórmula se cumple perfectamente:

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

Dado que Alice no conoce $d$ y un espía tampoco conoce $d$, ¡el único que puede extraer $M$ de $C$ es Bob, que tiene $d$!

7. Ejemplo concreto: Experimentemos el RSA calculando a mano con números primos pequeños

Intentemos comunicarnos de forma cifrada desde Alice a Bob utilizando números pequeños (números primos) reales.

[Fase de generación de claves de Bob]

Elige dos números primos $p=11$, $q=13$.
Calcula $N = 11 \times 13 = 143$.
Calcula $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Elige una clave pública $e$ coprima con $\phi(N)=120$. Aquí elegimos $e=7$.
Calcula la clave privada $d$. Buscamos $d$ tal que $7 \times d \equiv 1 \pmod{120}$. En la ecuación $7d = 120k + 1$, cuando $k=6$, esto es $721$, y $721 \div 7 = 103$. Por lo tanto, $d = 103$.

Clave pública: $(N=143, e=7)$
Clave privada: $d=103$

[Fase de cifrado de Alice] Supongamos que queremos enviar el mensaje $M = 9$. Fórmula: $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$. Dividiendo esto por 143, da $33447$ con un resto de $48$. El texto cifrado resultó ser $C = 48$.

[Fase de descifrado de Bob] Bob recibe el texto cifrado $C = 48$ y lo descifra usando la clave privada $d = 103$. Fórmula: $M \equiv 48^{103} \pmod{143}$ Si ejecutas (48 ** 103) % 143 en una calculadora, ¡el resultado es espectacularmente “9”! Pudo recibir el mensaje original sin problemas.

8. Cómo calcular la clave privada $d$: Algoritmo de Euclides extendido

En el ejemplo de cálculo a mano, buscamos $k$ por intuición para encontrar $d=103$, pero cuando los números tienen cientos de dígitos, este método es imposible. En los programas reales, se utiliza un algoritmo llamado “Algoritmo de Euclides extendido”.

Resolver $7d \equiv 1 \pmod{120}$ es lo mismo que encontrar enteros $d, y$ que cumplan con $7d + 120y = 1$. Se puede encontrar esto mecánicamente haciendo el proceso inverso del algoritmo de Euclides.

$120 \div 7 = 17$ con resto $1$
Transformando esto, $1 = 120 - 17 \times 7$
En otras palabras, $-17 \times 7 \equiv 1 \pmod{120}$

$-17$ significa lo mismo que $120 - 17 = 103$ en el mundo del módulo $120$. Por lo tanto, $d = 103$ se encuentra en un instante. Este método puede calcular muy rápido sin importar cuán gigante sea el número.

9. Otra cara del cifrado RSA: Firmas digitales

Lo maravilloso del cifrado RSA es que, invirtiendo los roles de la clave pública y la clave privada, también se puede utilizar como “firma digital”.

En el cifrado, era “cifrar con clave pública $\Rightarrow$ descifrar con clave privada”, pero en las firmas digitales, se siguen los pasos de “cifrar con clave privada $\Rightarrow$ descifrar con clave pública”.

flowchart TD A1["1. Alice crea una firma con su clave privada"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Envía el mensaje M y la firma S"] A3 --> B1["2. Bob verifica la firma con la clave pública"] B1 --> B2["Calcula M' ≡ S^e (mod N)"] B2 --> B3["Comprueba si M' y M coinciden"]

Alice convierte un mensaje utilizando su propia clave privada $d$ (esta es la firma $S$) y lo envía a Bob. Bob utiliza la clave pública de Alice $e$ para calcular la verificación. Si el resultado del cálculo coincide con el mensaje original, se prueba simultáneamente que “son datos que solo se pueden crear con la clave privada de Alice” y que “el mensaje no ha sido alterado en el camino”.

10. Experimentando el cifrado RSA con programación

El cálculo de potencias, que es difícil de hacer a mano, se puede implementar muy fácilmente utilizando Python. El siguiente es un código de Python que permite experimentar la lógica central del cifrado RSA.

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


def gcd(a, b):
 """Calcular el máximo común divisor"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Encontrar la clave privada d (Usando la función integrada desde Python 3.8)"""
 return pow(e, -1, phi)

# 1. Generación de claves
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

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

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

# 3. Descifrado
decrypted_message = pow(ciphertext, d, N)
print(f"Mensaje descifrado: {decrypted_message}")

La función pow(base, exp, mod) de Python utiliza internamente un algoritmo rápido llamado “exponenciación binaria” (repetir cuadrados), por lo que incluso con números de cientos de dígitos, el cálculo finaliza en un instante.

11. Resumen y futuras tecnologías criptográficas

Hemos desentrañado el mecanismo del cifrado RSA basándonos en los conocimientos de matemáticas de secundaria.

La dificultad de la factorización en números primos: $p \times q = N$ es fácil, pero encontrar $p, q$ a partir de $N$ es muy difícil.
Congruencias y el Teorema de Euler: A través de la ley $a^{\phi(N)} \equiv 1 \pmod N$, se completa la puerta trasera mágica que dice “al elevar a una potencia con un número determinado, se vuelve al original”.
Clave pública y clave privada: Cualquiera puede cifrar, pero solo el receptor legítimo puede descifrar.

El $N$ del cifrado RSA utilizado actualmente tiene más de 600 dígitos, y tomaría más tiempo que la edad del universo factorizarlo en números primos, incluso si se movilizaran todas las supercomputadoras del mundo. Sin embargo, si la “computadora cuántica”, cuya investigación ha avanzado en los últimos años, se vuelve práctica en el futuro, existe la posibilidad de que esta factorización en números primos se resuelva en un instante mediante el “algoritmo de Shor”. Por lo tanto, actualmente se está avanzando a un ritmo acelerado en todo el mundo en el desarrollo de la “criptografía poscuántica” que ni siquiera las computadoras cuánticas puedan descifrar.

Las matemáticas avanzadas, que a menudo se consideran “inútiles”, en realidad protegen nuestra vida diaria desde su base. El cifrado RSA es el mejor material de enseñanza que nos enseña esa profundidad y belleza de las matemáticas. Sería genial si pudieras sentir, aunque sea un poco, la diversión de la criptografía y las matemáticas a través de este artículo.

¿Existe un algoritmo que supere a GNFS (Criba General del Cuerpo de Números)?

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

1. Introducción: La factorización de enteros y la base de la criptografía moderna

La seguridad de las comunicaciones por internet en la sociedad moderna depende en gran medida de la seguridad del cifrado RSA, que es un sistema de cifrado de clave pública. Y la seguridad del cifrado RSA se basa en la suposición matemática de la “dificultad de factorizar enormes números compuestos”. Si se descubriera un algoritmo de factorización de enteros extremadamente eficiente, la infraestructura de comunicaciones de todo el mundo se derrumbaría desde sus cimientos.

Actualmente, en la factorización de enteros enormes utilizando ordenadores clásicos, el algoritmo más rápido y poderoso que reina es la Criba General del Cuerpo de Números (GNFS: General Number Field Sieve). GNFS nació como una extensión de la Criba Especial del Cuerpo de Números (SNFS) propuesta a finales de la década de 1980, y hasta el día de hoy ha establecido récords de factorización de enormes números compuestos como RSA-768 y RSA-250.

Sin embargo, los criptógrafos y matemáticos siempre se han planteado las siguientes preguntas: “¿Existe algún algoritmo clásico que supere a GNFS?”, “¿Dónde están los límites de los ordenadores clásicos?” y “¿Cómo cambiarán los ordenadores cuánticos esta situación?”.

En este artículo, analizaremos en profundidad la profunda estructura matemática detrás de GNFS y realizaremos un análisis técnico detallado de la selección de polinomios, el proceso de cribado y los pasos de álgebra lineal utilizando el algoritmo de Wiedemann por bloques. Además, consideraremos los métodos de extensión de GNFS a través de las mejoras de Coppersmith y otros, y compararemos y explicaremos las diferencias decisivas entre los algoritmos clásicos de tiempo subexponencial (Sub-exponential time) y los algoritmos cuánticos de tiempo polinómico desde una perspectiva matemática.

2. Complejidad asintótica y notación L (L-notation)

Al evaluar la complejidad de los algoritmos de factorización de enteros, en lugar de utilizar la notación estándar de tiempo polinómico (como $O(n^k)$), se utiliza la notación L (L-notation) para expresar el tiempo subexponencial con respecto al número de dígitos de la entrada $n$. La notación L se define de la siguiente manera:

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

Aquí, $n$ es el número entero a factorizar, y $\ln n$ es el logaritmo natural, el cual es proporcional a la longitud de bits de $n$.

Caso $\alpha = 0$: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$, lo que representa un tiempo polinómico (Polynomial time) con respecto a la longitud de bits.
Caso $\alpha = 1$: $L_n[1, c] = \exp(c \ln n) = n^c$, lo que representa un tiempo exponencial (Exponential time) con respecto a la longitud de bits.
Caso $0 < \alpha < 1$: Se sitúa entre el tiempo polinómico y el tiempo exponencial, lo que resulta en un tiempo subexponencial (Sub-exponential time).

La historia de la evolución de los algoritmos de factorización de enteros ha sido también la historia de la reducción gradual de este valor $\alpha$.

Método de Fracciones Continuas (CFRAC) y Criba Cuadrática de Polinomios Múltiples (MPQS): Pertenecen a la clase de $\alpha = 1/2$, y su complejidad es de alrededor de $L_n[1/2, 1]$.
Criba General del Cuerpo de Números (GNFS): Alcanzó $\alpha = 1/3$, y cuenta con la complejidad de $L_n[1/3, (64/9)^{1/3}]$, la más rápida entre los algoritmos clásicos conocidos actualmente.

3. Visión general del algoritmo GNFS (Criba General del Cuerpo de Números) y su estructura matemática

GNFS tiene una base matemática sumamente compleja y avanzada. La idea básica se encuentra en la extensión del pequeño teorema de Fermat y la criba cuadrática (QS), y consiste en encontrar un par no trivial $(X, Y)$ que satisfaga la congruencia $X^2 \equiv Y^2 \pmod n$ y que $X \not\equiv \pm Y \pmod n$, para luego derivar un factor $\gcd(X-Y, n)$ de $n$.

Sin embargo, la esencia de GNFS es que no realiza esto solo en el cuerpo de los números racionales $\mathbb{Q}$, sino que busca simultáneamente “números suaves (Smooth numbers)” tanto en un cuerpo de extensión llamado cuerpo de números algebraicos (Algebraic Number Field) $\mathbb{Q}(\alpha)$ como en el cuerpo de los números racionales, y construye la relación de congruencia a través de un homomorfismo.

El proceso de GNFS se divide principalmente en 5 fases.

graph TD A["Problema de factorización (entrada n)"] --> B["1. Selección de polinomios (Polynomial Selection)"] B --> C["2. Fase de cribado (Sieving Phase)"] C --> D["3. Fase de filtrado (Filtering Phase)"] D --> E["4. Fase de álgebra lineal (Linear Algebra Phase)"] E --> F["5. Fase de raíz cuadrada (Square Root Phase)"] F --> G["Salida de factores primos p, q"]

3.1 Fase 1: Selección de polinomios (Polynomial Selection)

El éxito de GNFS depende en gran medida de la elección adecuada de los polinomios. El objetivo es encontrar dos polinomios irreducibles, $f_1(x)$ (lado racional) y $f_2(x)$ (lado algebraico), que compartan una raíz común $m$. Es decir, satisfacen: $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$

Generalmente, para el polinomio del lado racional se elige una expresión lineal $f_1(x) = x - m$, y para el polinomio del lado algebraico $f_2(x)$ se elige un polinomio mónico de grado $d$ (típicamente 5 o 6). El enfoque más clásico es el método de base $m$ (Base-$m$ method). Se elige un entero $m = \lfloor n^{1/(d+1)} \rfloor$ que se aproxima a $n$ elevado a $1/(d+1)$, y se expande $n$ en base $m$. $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ De este modo, se obtiene el polinomio $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$. Obviamente, $f_2(m) = n \equiv 0 \pmod n$.

Sin embargo, en las implementaciones modernas se utiliza el algoritmo de Kleinjung. Éste optimiza las propiedades algebraicas (como el valor $E$ de Murphy o el valor $\alpha$) evitando que los coeficientes del polinomio se vuelvan extremadamente grandes (optimización de asimetría o Skewness), y busca polinomios que faciliten la generación de números suaves en el proceso de cribado. Solamente en este paso se invierten enormes recursos computacionales.

3.2 Fase 2: Fase de cribado (Sieving Phase)

Una vez que se deciden los polinomios, se entra en la fase de “cribado (Sieving)”, que es la que soporta la mayor carga computacional del algoritmo. Aquí se busca un par $(a, b)$. Se requiere que este par sea coprimo, y que los dos valores siguientes sean simultáneamente “suaves (Smooth)”.

Norma en el lado racional: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
Norma en el lado algebraico: $F_2(a, b) = b^d \cdot f_2(a/b)$

“Suave” significa que puede ser factorizado únicamente por números primos que se encuentren por debajo de un límite especificado (Sieve bound). Se preparan una base de factores (Factor base) para el lado racional y otra para el lado algebraico, y sobre un enorme espacio de búsqueda, se descubren eficientemente los números suaves utilizando un enfoque similar a la Criba de Eratóstenes. En la actualidad, la técnica principal es el método conocido como criba de retículos (Lattice Sieving), en la cual, al fijar un número primo específico $q$, se criban únicamente los pares $(a, b)$ de una subred que hacen que tanto el lado racional como el algebraico sean múltiplos de $q$, logrando así una eficiencia extremadamente alta.

3.3 Fase 3: Fase de filtrado (Filtering Phase)

El número de relaciones suaves encontradas en el proceso de cribado puede alcanzar cientos o miles de millones. Sin embargo, estas también incluyen mucha información inútil. El objetivo del filtrado es construir una enorme matriz dispersa (Sparse Matrix) y, al mismo tiempo, reducir su dimensión lo máximo posible.

Específicamente se realizan las siguientes operaciones:

Eliminación de relaciones únicas (Singleton removal): Se eliminan las relaciones que contienen factores primos que aparecen solo una vez.
Eliminación y fusión de clanes (Clique removal / Merging): Las relaciones con factores primos que aparecen dos o más veces se multiplican entre sí para eliminar variables, contrayéndolas en un sistema de ecuaciones más denso, pero de menor dimensión.

Como resultado, una matriz de miles de millones de filas se comprime a una enorme matriz dispersa $\mathbf{A}$ de unos pocos millones de filas (cuyos elementos son 0 y 1 sobre el cuerpo $\mathbb{F}_2$).

3.4 Fase 4: Fase de álgebra lineal (Linear Algebra Phase)

Aquí se busca un vector solución no trivial $\mathbf{x}$ de la ecuación $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$. En otras palabras, se trata del problema de encontrar el espacio nulo izquierdo (Left Nullspace) de la enorme matriz dispersa.

Debido a que el tamaño de la matriz es extremadamente grande, es absolutamente imposible calcularlo con la eliminación Gaussiana habitual ($O(N^3)$). En su lugar, se emplean métodos iterativos que son un tipo de método de subespacio de Krylov. Históricamente, se ha utilizado el método de Lanczos por bloques (Block Lanczos), pero en el entorno de computación distribuida actual, el algoritmo de Wiedemann por bloques (Block Wiedemann Algorithm), que puede reducir drásticamente los cuellos de botella de la comunicación, es el predominante.

El método de Wiedemann por bloques calcula el polinomio mínimo a partir de la matriz $\mathbf{A}$ y una secuencia de vectores, y utiliza el algoritmo de Berlekamp-Massey para construir la base del espacio nulo. Este paso es sumamente difícil de paralelizar y es uno de los mayores cuellos de botella de GNFS, ya que requiere redes de comunicación estrechamente acopladas de supercomputadoras o clústeres a gran escala.

3.5 Fase 5: Fase de raíz cuadrada (Square Root Phase)

A partir de la solución del álgebra lineal, se construye un producto que será un “cuadrado perfecto” tanto en el lado racional como en el algebraico. En el lado racional, el producto $\prod (a-bm)$ se convierte en el cuadrado $X^2$ de algún entero $X$, y en el lado algebraico, el producto de los ideales correspondientes se convierte en un cuadrado perfecto $\gamma^2$ sobre el cuerpo de los números algebraicos. Al calcular este $\gamma$ en el cuerpo de los números algebraicos y aplicar el homomorfismo $\phi: \alpha \mapsto m \pmod n$ hacia el anillo de los enteros racionales, se obtiene la congruencia: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$

Para el cálculo de la raíz cuadrada en el cuerpo de los números algebraicos se utilizan algoritmos complejos como el método de Montgomery (Montgomery’s Method), lo cual exige un profundo conocimiento de la teoría de números algebraicos. Finalmente, se calcula $\gcd(X-Y, n)$ y, si se obtiene un factor no trivial, la factorización de enteros estará completada.

4. ¿Existe un algoritmo clásico que supere a GNFS?

Hasta la fecha, no se ha descubierto ningún algoritmo clásico para la factorización de enteros generales cuya complejidad asintótica caiga por debajo de $L_n[1/3, c]$. Sin embargo, existen varios algoritmos derivados e intentos de superar los límites teóricos y prácticos.

4.1 Criba Múltiple del Cuerpo de Números (MNFS: Multiple Number Field Sieve)

Como un enfoque extendido de GNFS, existe la Criba Múltiple del Cuerpo de Números (MNFS) de D. Coppersmith. En GNFS se utilizan 2 polinomios (lado racional y lado algebraico), pero en MNFS se utilizan varios polinomios algebraicos diferentes simultáneamente contra un solo polinomio racional.

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

Al utilizar múltiples cuerpos algebraicos, se puede aumentar drásticamente la probabilidad de que “sea suave en alguno de los cuerpos algebraicos” en cada paso del cribado. Coppersmith logró reducir ligeramente la constante $c$ de la complejidad computacional $L_n[1/3, c]$ mediante este enfoque. Específicamente, se ha demostrado teóricamente que mientras la constante de GNFS es $c = (64/9)^{1/3} \approx 1.923$, al optimizar MNFS, el costo computacional puede reducirse hasta un valor cercano a $c \approx 1.902$. Sin embargo, en la práctica, la carga adicional (overhead) de gestionar múltiples cuerpos es enorme y no se ha logrado un avance decisivo frente al módulo RSA a una escala de aplicación práctica.

4.2 ¿Es posible un algoritmo de la clase $L_n[1/4]$?

Con respecto a los límites de los algoritmos clásicos de factorización de enteros, un tema largamente debatido entre los matemáticos es la pregunta: “¿Existe un algoritmo con exponente $\alpha = 1/4$?”. El actual GNFS y sus derivados están fuertemente condicionados por el marco de “búsqueda de suavidad” a través de cribas, y se cree ampliamente que dentro de este paradigma, $\alpha = 1/3$ es el límite. A partir del análisis de la probabilidad de distribución de los enteros suaves usando la función de Dickman (Dickman function), se cree que con la actual combinación de construcción de cuerpos algebraicos y cribas, sin importar cómo se optimice, no se puede superar la barrera de $O(L_n[1/3])$.

Si existiera un algoritmo de $L_n[1/4]$, o incluso un algoritmo clásico de tiempo polinómico, tendría que depender de una nueva estructura matemática completamente diferente del enfoque “basado en suavidad” como GNFS, que en la actualidad la humanidad no puede ni siquiera imaginar (por ejemplo, un enfoque geométrico-algebraico más avanzado, como el algoritmo de Schoof para la criptografía de curva elíptica). Sin embargo, por el momento, no hay indicios de ello.

5. El gran avance gracias a la computación cuántica: El algoritmo de Shor

Mientras que los ordenadores clásicos se enfrentan a la barrera de $L_n[1/3]$, el algoritmo de Shor (Shor’s Algorithm), presentado por Peter Shor en 1994, destruyó esta barrera al cambiar fundamentalmente el propio modelo de cálculo.

5.1 El impacto del tiempo polinómico cuántico

El algoritmo de Shor reduce el problema de factorización de enteros al “Problema de encontrar el orden (Order Finding Problem)”. Dado cierto entero $a$, es el problema de encontrar el período (orden) $r$ de la función $f(x) = a^x \pmod n$. Un ordenador clásico requiere un tiempo exponencial para encontrar este período, pero usando la Estimación Cuántica de Fase (QPE: Quantum Phase Estimation) y la Transformada Cuántica de Fourier (QFT: Quantum Fourier Transform) en un ordenador cuántico, se puede evaluar de forma paralela en la superposición (Superposition) de todos los estados y extraer el período $r$ con alta probabilidad.

Desde el punto de vista de la complejidad computacional, el tiempo de ejecución del algoritmo de Shor es de tiempo polinómico cuántico, concretamente de la siguiente manera:

$$ O((\log n)^3) $$

Teniendo en cuenta las implementaciones de circuitos optimizadas recientemente, se dice que es posible reducirlo hasta $O((\log n)^2 \log \log n)$.

graph LR A["Algoritmo clásico (GNFS)"] -->|Límite| B["Tiempo subexponencial L_n[1/3]"] C["Algoritmo cuántico (Shor)"] -->|Gran avance| D["Tiempo polinómico O((log n)^3)"] B --> E["Uso continuo del cifrado RSA (Aumento de longitud de clave)"] D --> F["Colapso total del cifrado RSA"]

5.2 Tiempo subexponencial clásico vs Tiempo polinómico cuántico

La diferencia entre estas dos clases de complejidad computacional tiene un significado crucial en la seguridad de la criptografía del mundo real.

Por ejemplo, considere el caso de factorizar RSA-2048 (un número compuesto de 2048 bits).

GNFS (Clásico): Al sustituir $n \approx 2^{2048}$ en $L_n[1/3, 1.923]$, se requieren aproximadamente $2^{112}$ operaciones. Esta es una cantidad astronómica de cálculos que tomaría más del tiempo de vida del universo, incluso combinando todos los recursos de computación de la Tierra en la actualidad.
Algoritmo de Shor (Cuántico): Con el algoritmo de $O((\log n)^3)$, tomaría aproximadamente $2048^3 \approx 8.5 \times 10^9$ operaciones de puertas lógicas. Esto significa que si existiera el hardware adecuado (un ordenador cuántico universal con millones de cúbits físicos y capacidad de corrección de errores), el cálculo se completaría en tan solo unas horas o unos días.

El cambio de paradigma del tiempo subexponencial de “exponente $\alpha=1/3$” al “tiempo polinómico” neutraliza la estrategia tradicional de la criptografía de garantizar la seguridad extendiendo la longitud de la clave.

6. Conclusión: Perspectivas hacia la próxima generación

El consenso actual en la comunidad científica frente a la pregunta “¿Existe algún algoritmo clásico que supere a GNFS?” es el siguiente:

Las mejoras prácticas continúan, pero no hay un salto asintótico: Los intentos de mejorar el término constante $c$ de GNFS continúan, como en el caso de MNFS, la optimización de la selección de polinomios y la paralelización del algoritmo de Wiedemann por bloques. Sin embargo, se considera que la posibilidad de descubrir un algoritmo clásico que caiga por debajo de $\alpha = 1/3$ es extremadamente baja.
La seguridad de RSA en ordenadores clásicos sigue siendo robusta: La complejidad computacional de GNFS sigue siendo inmensa, y RSA-2048 y RSA-4096 seguirán siendo seguros frente a ataques a través de ordenadores clásicos durante las próximas décadas.
La verdadera amenaza es el algoritmo cuántico: El que ha cruzado la barrera de la complejidad computacional es el algoritmo de Shor, basado en los principios de la mecánica cuántica. Debido a esto, el mundo se está viendo obligado a migrar hacia la criptografía poscuántica (PQC: Post-Quantum Cryptography). La vanguardia de la criptografía actual consiste en la transición a nuevos problemas matemáticos, como la criptografía basada en retículos y la criptografía basada en hash, que se consideran difíciles de descifrar (imposibles de resolver en tiempo polinómico) incluso para los ordenadores cuánticos.

La Criba General del Cuerpo de Números (GNFS) es uno de los “mayores logros” alcanzados por la humanidad al desafiar los límites de las matemáticas clásicas y el diseño de algoritmos. Comprender la profunda estructura matemática de GNFS no es solo aprender sobre la historia del criptoanálisis, sino que también es un viaje de exploración intelectual para entrar en contacto con la belleza de la teoría de la complejidad computacional y la teoría de los números algebraicos. Hasta el día en que los ordenadores cuánticos se implementen de forma práctica, GNFS seguramente seguirá defendiendo su trono como el algoritmo de factorización de enteros más poderoso.