Mathematics on kenji.blog

Intuición matemática de la criptografía basada en retículos (Lattice-based cryptography)

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

1. Introducción: El amanecer de la criptografía poscuántica (PQC) y el auge de la criptografía basada en retículos

La infraestructura digital de la sociedad moderna se basa en tecnologías de criptografía de clave pública, como el cifrado RSA y la criptografía de curva elíptica (ECC). Estos métodos basan su seguridad en la dificultad matemática de problemas como la “factorización de enteros” o el “logaritmo discreto”, los cuales se cree que no pueden resolverse eficientemente (requieren tiempo exponencial) con computadoras clásicas convencionales.

Sin embargo, el “Algoritmo de Shor”, publicado por Peter Shor en 1994, sacudió el mundo de la criptografía. Este algoritmo demostró matemáticamente que una vez que se construyan computadoras cuánticas a gran escala, estas podrán resolver los problemas de factorización de enteros y de logaritmo discreto en tiempo polinomial. Esto significa que la criptografía de clave pública ampliamente utilizada en la actualidad se volverá completamente descifrable en el futuro.

Para contrarrestar esta “Amenaza Cuántica (Quantum Threat)”, se hizo imperativo investigar nuevos métodos de cifrado que sean difíciles de descifrar incluso utilizando computadoras cuánticas. Este es el campo conocido como “Criptografía Poscuántica (Post-Quantum Cryptography: PQC)” o “Criptografía resistente a la computación cuántica”.

Existen varios candidatos prometedores para la PQC, como la criptografía basada en hashes, la criptografía basada en códigos, la criptografía multivariable y la criptografía basada en isogenias. Sin embargo, el método que actualmente atrae más la atención y que está en el centro del proceso de estandarización de PQC por parte del NIST (Instituto Nacional de Estándares y Tecnología de EE. UU.) es la “Criptografía basada en retículos (Lattice-based cryptography)”. En comparación con otros métodos, la criptografía de retículos ofrece velocidades de cifrado y descifrado muy rápidas, y cuenta con una característica destacada: una prueba de seguridad extremadamente sólida en la teoría criptográfica basada en la reducción de la “complejidad en el peor de los casos (Worst-case complexity)” a la “complejidad en el caso promedio (Average-case complexity)”.

En este artículo, partiremos de la definición matemática de “Retículo (Lattice)”, que es la base de esta criptografía, y explicaremos profundamente mediante fórmulas, intuición geométrica y ejemplos numéricos específicos los problemas difíciles sobre retículos como SVP (Problema del vector más corto) y CVP (Problema del vector más cercano), y el corazón de la criptografía de retículos moderna, el “Problema LWE (Learning With Errors)”.

2. Definición matemática e intuición geométrica de un Retículo (Lattice)

2.1 Espacio vectorial y retículos

En matemáticas, un “Retículo (Lattice)” es un conjunto discreto de puntos dispuestos regularmente en un espacio vectorial real de $n$ dimensiones $\mathbb{R}^n$. Es similar al espacio vectorial (Vector Space) que se estudia en álgebra lineal, pero existe una diferencia crucial. Mientras que un espacio vectorial es un espacio continuo representado por combinaciones lineales de vectores base con “coeficientes reales”, un retículo es un espacio discreto representado por combinaciones lineales de vectores base con “coeficientes enteros”.

Demos una definición matemática rigurosa. Consideremos $n$ vectores linealmente independientes $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ (donde $n \le m$) en un espacio vectorial real de $m$ dimensiones $\mathbb{R}^m$. Sea $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$ una matriz que tiene estos vectores como columnas. Llamamos a esta $B$ la “Base (Basis)” del retículo.

El retículo $\mathcal{L}(B)$ generado por esta base $B$ se define de la siguiente manera:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

Lo importante aquí es que los coeficientes $x_i$ están limitados a números enteros $\mathbb{Z}$, en lugar de números reales $\mathbb{R}$. Como resultado, en lugar de puntos continuos que existen en un número infinito en el espacio, se forma un “conjunto discreto de puntos” similar a las intersecciones espaciadas uniformemente en una cuadrícula.

2.2 Imagen geométrica

Consideremos un ejemplo en el plano bidimensional $\mathbb{R}^2$. Si elegimos los vectores base $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ y $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$, el retículo generado por ellos será el conjunto de todas las coordenadas enteras $(x, y) \in \mathbb{Z}^2$ en el plano cartesiano. Este es el “retículo cuadrado” más simple.

Sin embargo, los retículos no siempre son ortogonales. Por ejemplo, considerando una base como $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ y $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, los puntos generados se parecerán a las intersecciones de una malla sesgada diagonalmente.

2.3 No unicidad de la base y transformación unimodular

Existe una propiedad importante relacionada con la base de la seguridad de la criptografía de retículos: “existen infinitas bases que generan el mismo retículo”.

Por ejemplo, el retículo $\mathbb{Z}^2$ generado por la base $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ mencionada anteriormente es exactamente el mismo retículo $\mathbb{Z}^2$ que el generado por la base $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$.

La condición necesaria y suficiente para que una base $B$ y otra base $B'$ generen el mismo retículo es que exista una matriz con componentes enteros $U \in \mathbb{Z}^{n \times n}$ cuyo determinante sea $\det(U) = \pm 1$, tal que:

$$ B' = B U $$

A una matriz $U$ de este tipo se le llama “Matriz unimodular (Unimodular matrix)”.

La idea básica en la aplicación a la criptografía es utilizar una “buena base” (una base casi ortogonal formada por vectores cortos) como clave privada, y una “mala base” (una base con vectores extremadamente oblicuos entre sí y muy largos) como clave pública. Calcular una buena base a partir de una mala base se vuelve muy difícil a medida que aumentan las dimensiones. Esta es la intuición básica de la criptografía basada en retículos.

3. Problemas computacionalmente difíciles en retículos

La seguridad de la criptografía basada en retículos depende de la dificultad de resolver problemas matemáticos específicos en los retículos. Aquí presentaremos dos de los problemas más fundamentales y conocidos.

3.1 Problema del vector más corto (Shortest Vector Problem: SVP)

SVP es el problema más clásico y famoso de la teoría de retículos.

Definición (SVP): Dada una base de retículo arbitraria $B$, encontrar el vector $\mathbf{v}$ distinto de cero que pertenece al retículo $\mathcal{L}(B)$ y tiene la norma euclidiana (longitud) mínima.

Expresado en fórmula matemática, es el problema de encontrar $\mathbf{v}$ tal que $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. A esta longitud mínima se le denota como $\lambda_1(\mathcal{L})$ y se le llama “Primer mínimo sucesivo (First successive minimum) del retículo”.

En dimensiones bajas como 2 o 3, podemos encontrar el vector más corto visualmente dibujando un gráfico, o podemos resolverlo eficientemente usando algoritmos como el algoritmo de reducción de bases de Gauss. Sin embargo, cuando la dimensión $n$ alcanza valores altos como cientos o miles, se sabe que resolver estrictamente SVP es NP-difícil.

En criptografía real, no se busca el vector más corto estricto, sino que se utiliza un SVP aproximado ($\gamma$-SVP) para encontrar un “vector aproximadamente corto”. Si el factor de aproximación $\gamma$ es de tamaño polinomial, este problema se sigue considerando extremadamente difícil.

3.2 Problema del vector más cercano (Closest Vector Problem: CVP)

CVP es también un problema de extrema importancia en la criptografía basada en retículos.

Definición (CVP): Dada una base de retículo arbitraria $B$ y un vector objetivo arbitrario $\mathbf{t} \in \mathbb{R}^m$ en el espacio (que no necesariamente es un punto del retículo), encontrar el punto del retículo $\mathbf{v} \in \mathcal{L}(B)$ más cercano a $\mathbf{t}$.

Expresado matemáticamente, es el problema de buscar un punto de retículo $\mathbf{v}$ tal que $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

Al igual que SVP, CVP también es NP-difícil en altas dimensiones. Desde la perspectiva de la aplicación criptográfica, el problema LWE que discutiremos más adelante está estrechamente relacionado con una variante especial de este CVP (Decodificación de distancia acotada o Bounded Distance Decoding: BDD).

3.3 ¿Por qué es insoluble en altas dimensiones? (Los límites de LLL y BKZ)

Un algoritmo famoso para resolver problemas de retículos de altas dimensiones es el algoritmo LLL (Lenstra-Lenstra-Lovász algorithm). El algoritmo LLL se ejecuta en tiempo polinomial y puede reducir en cierta medida la base del retículo a una “buena base”. Sin embargo, el vector más corto que el algoritmo LLL puede encontrar tiene un factor de aproximación exponencial ($2^{\mathcal{O}(n)}$) en relación con la longitud del vector más corto verdadero, por lo que no es suficiente para romper la seguridad criptográfica.

Si se utiliza un algoritmo de reducción de bases más potente como el algoritmo BKZ (Block Korkine-Zolotarev), que es una mejora de LLL, se pueden encontrar vectores más cortos, pero su complejidad computacional aumenta exponencialmente con respecto al tamaño del bloque. En la criptografía de retículos, los parámetros seguros (como el tamaño de la dimensión $n$) se determinan estimando el tiempo de ejecución de este algoritmo BKZ. Con los parámetros estándar actuales de PQC, se eligen dimensiones $n$ de 500 a 1000 o más, y se considera que descifrarlos tomaría más tiempo que la edad del universo, incluso utilizando supercomputadoras o futuras computadoras cuánticas.

4. Formulación matemática del problema LWE (Learning With Errors)

La mayor parte de la criptografía de retículos moderna se basa en el “Problema LWE (Learning With Errors)” propuesto por Oded Regev en 2005. La belleza del problema LWE radica en la simplicidad de su formulación y en el hecho de que cuenta con una poderosa prueba matemática de “reducción de la complejidad en el peor caso a la complejidad en el caso promedio”.

4.1 Sistema de ecuaciones lineales sin ruido

Para entender el problema LWE, primero consideremos un simple sistema de ecuaciones lineales sin ruido. Supongamos que hay un vector secreto desconocido $\mathbf{s} \in \mathbb{Z}_q^n$ (donde cada componente es un número entero de $0$ a $q-1$). Aquí $q$ es un número primo.

Elegimos vectores de coeficientes aleatorios $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ y calculamos su producto interno con el vector secreto $\mathbf{s}$ módulo $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Si se nos da un número suficiente (al menos $n$) de pares $(\mathbf{a}_i, b_i)$, podemos recuperar fácilmente el vector secreto $\mathbf{s}$ usando la “Eliminación de Gauss (Gaussian elimination)” de álgebra lineal. Este es un problema que puede resolverse fácilmente en tiempo polinomial.

4.2 Definición del problema LWE: Agregando ruido

Entonces, ¿qué sucedería si añadimos un ligero “ruido (error)” a este problema? Esta es la esencia del problema LWE.

Para el vector secreto desconocido $\mathbf{s} \in \mathbb{Z}_q^n$, añadimos un pequeño error $e_i \in \mathbb{Z}_q$ al resultado de cada ecuación. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Aquí, $e_i$ es un pequeño valor entero con media 0 y una desviación estándar relativamente pequeña (por ejemplo, elegido de una distribución gaussiana discreta, similar a una distribución normal). La información proporcionada es una lista de pares de un vector aleatorio $\mathbf{a}_i$ y $b_i$ calculado añadiendo un error. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Representar esto en forma matricial lo hace muy claro. Usando una matriz aleatoria $A \in \mathbb{Z}_q^{m \times n}$, un vector secreto $\mathbf{s} \in \mathbb{Z}_q^n$ y un vector de error $\mathbf{e} \in \mathbb{Z}_q^m$:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

Solo se nos proporciona $A$ y $\mathbf{b}$. Encontrar $\mathbf{s}$ a partir de aquí es el “Problema de búsqueda LWE (Search LWE problem)”.

Debido a que el error $e_i$ está presente, intentar usar la eliminación de Gauss amplificaría el error de forma exponencial durante el proceso de sumar y restar ecuaciones, haciendo imposible llegar a la respuesta correcta. A primera vista, parece un simple sistema de ecuaciones lineales, pero al agregar este pequeño ruido, la dificultad del problema se eleva al nivel de NP-difícil.

4.3 Problema LWE de decisión (Decision LWE)

En las pruebas de la teoría criptográfica, la variante frecuentemente utilizada es el “Problema LWE de decisión (Decision LWE problem)”, que es una variante del problema de búsqueda LWE.

El problema LWE de decisión es el problema de determinar de cuál de las siguientes dos distribuciones proviene una lista de muestras dada:

Distribución LWE: $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$ calculada intencionadamente.
Distribución aleatoria uniforme: $(A, \mathbf{u})$ formada por una matriz $A$ y un vector $\mathbf{u}$ elegidos de forma completamente aleatoria.

Sorprendentemente, si se eligen adecuadamente los parámetros del problema LWE, los pares obtenidos de la distribución LWE se vuelven “computacionalmente indistinguibles (Computationally Indistinguishable)” de los pares de datos completamente aleatorios. Esta propiedad es la base que permite a la criptografía basada en LWE generar “textos cifrados indistinguibles de números aleatorios”.

4.4 Reducción de la complejidad en el peor caso a la del caso promedio (Teorema de Regev)

El mayor logro de Oded Regev fue vincular matemáticamente la dificultad de este problema LWE con la dificultad de los problemas de retículos mencionados anteriormente (SVP y CVP).

Utilizó la reducción cuántica (Quantum reduction) para demostrar que “si existe un algoritmo de tiempo polinomial capaz de resolver el problema LWE en el caso promedio (para $A$ y $\mathbf{e}$ elegidos al azar), entonces existe un algoritmo cuántico de tiempo polinomial capaz de resolver el Gap-SVP en el peor caso (el caso más difícil) para cualquier retículo”. (Posteriormente, Peikert y otros también demostraron una reducción clásica).

Esta es una propiedad soñada en la teoría criptográfica. Esto se debe a que disipa la preocupación de que “la criptografía podría romperse si por casualidad elegimos una clave débil (una parte del caso promedio)” y ofrece una fuerte garantía de que “si se puede resolver el LWE promedio, entonces se pueden resolver todos los problemas difíciles del retículo (por lo tanto, el LWE es absolutamente difícil)”.

graph TD A["Problemas de retículos en el peor caso (Gap-SVP, SIVP)"] -->|Reducción Cuántica/Clásica| B["Problema LWE en el caso promedio"] B -->|Construcción Criptográfica| C["Criptosistemas basados en LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Construcción de un sistema de criptografía de clave pública utilizando LWE (Criptografía de Regev)

Habiendo entendido la dificultad del problema LWE, veamos cómo funciona el cifrado y descifrado usándolo en el sistema de criptografía de clave pública básico propuesto por Oded Regev. Aquí explicaremos el mecanismo más básico para cifrar un mensaje de 1 bit $M \in \{0, 1\}$.

5.1 Generación de claves (Key Generation)

Como parámetros del sistema, se determinan el módulo primo $q$, la dimensión $n$ y el número de ecuaciones $m$ ($m > n \log q$).
Se elige al azar el vector secreto $\mathbf{s} \in \mathbb{Z}_q^n$ como clave privada.
Se genera una matriz aleatoria $A \in \mathbb{Z}_q^{m \times n}$.
Se selecciona un pequeño vector de error $\mathbf{e} \in \mathbb{Z}_q^m$ a partir de una distribución de errores como la distribución gaussiana discreta.
Se calcula el vector $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
La clave pública (Public Key) será $(A, \mathbf{b})$.
La clave secreta o privada (Secret Key) será $\mathbf{s}$.

La clave pública es precisamente una “instancia del problema LWE”. Dado que derivar la clave secreta $\mathbf{s}$ a partir de la clave pública $(A, \mathbf{b})$ equivale a resolver el problema de búsqueda LWE, la seguridad está garantizada.

5.2 Cifrado (Encryption)

Alice cifra un mensaje de 1 bit $M \in \{0, 1\}$ utilizando la clave pública de Bob $(A, \mathbf{b})$.

Elige un vector binario aleatorio (con componentes 0 o 1) $\mathbf{r} \in \{0, 1\}^m$.
Como primera parte del texto cifrado, calcula el vector $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ es la matriz transpuesta de $A$. Es decir, suma las filas de $A$ donde el componente de $\mathbf{r}$ es 1).
Como segunda parte del texto cifrado, calcula el escalar $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Si el mensaje $M$ es 0, no suma nada; si es $1$, suma exactamente la mitad del valor de $q$, $\lfloor \frac{q}{2} \rfloor$).
El texto cifrado (Ciphertext) será $(\mathbf{u}, v)$.

La implicación intuitiva del cifrado es tomar la “suma de un subconjunto aleatorio” de la matriz de la clave pública $A$ y del vector $\mathbf{b}$. Debido a la dificultad del problema LWE de decisión, este texto cifrado $(\mathbf{u}, v)$ parece indistinguible de un vector completamente aleatorio y de un número aleatorio uniforme (Seguridad semántica: Semantic Security).

flowchart LR M["Mensaje M en {0,1}"] --> Enc PK["Clave Pública (A, b)"] --> Enc r["Vector binario aleatorio r"] --> Enc subgraph Enc ["Proceso de Cifrado"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Texto Cifrado (u, v)"]

5.3 Descifrado (Decryption)

Bob descifra el texto cifrado $(\mathbf{u}, v)$ usando su clave secreta $\mathbf{s}$.

Calcula el siguiente valor: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Si el resultado calculado está cerca de $0$, la salida es $M=0$; si está cerca de $\lfloor \frac{q}{2} \rfloor$, la salida es $M=1$.

Desarrollemos matemáticamente por qué se puede descifrar con esto. Recuerde que $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Aquí, $\mathbf{s}^T A^T \mathbf{r}$ se cancela claramente y desaparece de la ecuación. Lo que queda es $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ es un vector de ruido con componentes muy pequeños, y $\mathbf{r}$ es un vector binario con componentes de 0 o 1. Por lo tanto, su producto interno $\mathbf{e}^T \mathbf{r}$ también permanece como un valor relativamente pequeño (si los parámetros se eligen adecuadamente).

Si $M=0$, el resultado es $\mathbf{e}^T \mathbf{r}$, que será un valor pequeño cerca de $0$.
Si $M=1$, el resultado es $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, que se situará alrededor de la mitad del valor de $q$, $\lfloor \frac{q}{2} \rfloor$.

Si los parámetros están diseñados para que el valor absoluto del error $\mathbf{e}^T \mathbf{r}$ sea menor a $\frac{q}{4}$, Bob puede determinar (descifrar) con precisión el mensaje $M$ simplemente verificando si el resultado del cálculo está más cerca de $0$ o de $\lfloor \frac{q}{2} \rfloor$. Este es el hermoso mecanismo por el cual funciona la criptografía basada en LWE.

flowchart LR CT["Texto Cifrado (u, v)"] --> Dec SK["Clave Secreta s"] --> Dec subgraph Dec ["Proceso de Descifrado"] direction TB calc["Calcular D = v - s^T * u mod q"] check["Comprobar si D está más cerca de 0 o q/2"] end calc --> check Dec --> M_out["Mensaje Recuperado M"]

6. Ejemplo ilustrativo de criptografía LWE usando valores numéricos específicos

Es posible que resulte difícil comprender solo con una lista de fórmulas matemáticas, así que intentemos establecer parámetros numéricos muy pequeños y seguir los cálculos desde el cifrado hasta el descifrado. (* En un sistema de criptografía real, se utilizan valores para $n$ mayores de 500 y para $q$ valores de miles o más para garantizar la seguridad).

[Configuración de parámetros]

Módulo $q = 17$ (Un número primo. Por tanto, los valores están en el rango de $0$ a $16$).
Dimensión $n = 2$
Número de ecuaciones $m = 4$
Supondremos que se cifrará el mensaje $M = 1$.
Cantidad de desplazamiento del mensaje: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Fase de generación de claves] Bob elige su clave secreta $\mathbf{s}$, la matriz $A$ y el vector de error $\mathbf{e}$ al azar.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Luego calcula la clave pública $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Calculando esto módulo 17 (como $66 = 17 \times 3 + 15$ etc.):

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Sumando el vector de error $\mathbf{e}$:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

La clave pública es $A$ y $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Fase de cifrado] Alice cifra el mensaje $M = 1$. Elige un vector aleatorio $\mathbf{r}$. Aquí usaremos $\mathbf{r} = (1, 0, 1, 0)^T$.

Calcula $\mathbf{u}$:

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Calcula $v$:

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Suma el valor correspondiente al mensaje $M=1$, $\lfloor 17/2 \rfloor = 8$:

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Alice envía el texto cifrado $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ a Bob.

[3. Fase de descifrado] Bob, al recibir el texto cifrado, lo descifra usando su clave secreta $\mathbf{s} = (3, 4)^T$. Fórmula de descifrado: Calcula $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Aquí, en el mundo del módulo 17, $-8$ es igual a $9$ ($-8 + 17 = 9$). Determina si el valor obtenido $D = 9$ está más cerca de $0$ o de $8$ ($\lfloor 17/2 \rfloor$). Dado que $9$ está claramente más cerca de $8$ que de $0$, ¡Bob logra restaurar correctamente $M = 1$!

¿Por qué resultó 9? Recordemos la prueba anterior. La parte de error es $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Por lo tanto, el resultado del cálculo es $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, confirmando que se ha calculado el valor tal como en la teoría.

7. Evolución hacia la aplicación práctica: Ring-LWE y Module-LWE

El problema LWE estándar (Standard LWE) explicado hasta ahora tiene pruebas de seguridad muy sólidas, pero en la práctica tiene defectos fatales. Estos son el “tamaño gigante de las claves” y el “alto costo computacional”.

En Standard LWE, la clave pública incluye una matriz gigante $A \in \mathbb{Z}_q^{m \times n}$. Cuando el parámetro $n$ alcanza cifras entre cientos y miles, el tamaño de esta matriz llega a varios megabytes, lo que la hace demasiado pesada para enviar y recibir cada vez a través de protocolos de comunicación en internet (como TLS). Además, la multiplicación de matrices y vectores requiere una complejidad computacional de $\mathcal{O}(n^2)$.

Para resolver estos problemas se introdujeron el “Ring-LWE (RLWE)” y el “Module-LWE (MLWE)”, que incorporan estructuras algebraicas llamadas anillos de polinomios (Polynomial rings) en los retículos.

7.1 Intuición de Ring-LWE

En Ring-LWE, los vectores y matrices se sustituyen por elementos (polinomios) de un anillo de polinomios $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Donde $n$ se elige como una potencia de 2).

Mientras que la clave pública en Standard LWE era una matriz $A$, en Ring-LWE se utiliza un solo polinomio $a(x)$. La clave secreta $s(x)$ y el error $e(x)$ también se convierten en polinomios. La ecuación queda de la siguiente manera:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Al tratarse de multiplicación de polinomios, utilizando la “Transformada Teórica de Números (Number Theoretic Transform: NTT)”, que es similar a la Transformada Rápida de Fourier (FFT), la complejidad computacional se puede reducir drásticamente a $\mathcal{O}(n \log n)$. Además, debido a que el tamaño de la clave pública se reduce de una matriz a un solo polinomio, el tamaño de los datos se reduce a $\mathcal{O}(n)$. Esto proporciona una ventaja abrumadora en términos de ancho de banda de comunicación.

Matemáticamente, Ring-LWE se reduce a problemas en retículos con una simetría especial conocidos como “Retículos Ideales (Ideal Lattices)” en lugar de retículos generales.

7.2 Module-LWE y Estandarización del NIST (Kyber / ML-KEM)

Aunque Ring-LWE es eficiente, había una ligera preocupación de que la estructura algebraica especial del retículo ideal pudiera ser la base para futuros ataques. Por lo tanto, el “Module-LWE (MLWE)” tomó “lo mejor de ambos mundos”: la seguridad conservadora de Standard LWE y la eficiencia de Ring-LWE.

En Module-LWE, consideramos matrices y vectores pequeños cuyos elementos son polinomios. Es decir, manejamos módulos sobre anillos. Actualmente, “CRYSTALS-Kyber” (Nombre estandarizado: ML-KEM), que ha sido seleccionado por el NIST como estándar para el algoritmo de intercambio de claves PQC (KEM), está construido precisamente en base a la dificultad de este problema Module-LWE.

8. ¿Por qué es seguro contra las computadoras cuánticas?

Finalmente, tocaremos el núcleo de la pregunta: “¿Por qué se cree que la criptografía basada en retículos no se puede descifrar ni siquiera usando computadoras cuánticas?”

El algoritmo de Shor, que hace que las computadoras cuánticas rompan RSA y ECC, es esencialmente un algoritmo para resolver el “Problema del Subgrupo Oculto (Hidden Subgroup Problem: HSP)”. La estructura matemática (grupos abelianos finitos) detrás de RSA y ECC tiene periodicidad, y al usar una operación cuántica específica llamada Transformada Cuántica de Fourier (QFT), este período (el subgrupo oculto) se puede extraer de una vez.

Sin embargo, los problemas de retículos son fundamentalmente diferentes. Aunque los retículos también tienen periodicidad, lo que se busca en SVP y CVP son propiedades geométricas no lineales, como la “distancia más corta” o la “eliminación del ruido”. Incluso aplicando directamente la “Transformada Cuántica de Fourier sobre un grupo abeliano” como en el algoritmo de Shor, no se puede extraer eficientemente información útil que resuelva el problema del retículo. Hasta la fecha, no se han descubierto algoritmos cuánticos capaces de resolver SVP o LWE en tiempo polinomial, y se cree ampliamente que, a pesar del poder de cálculo paralelo de las computadoras cuánticas, el único método efectivo es una búsqueda casi exhaustiva (aproximadamente una aceleración de la raíz cuadrada mediante el algoritmo de Grover).

9. Conclusión

En este artículo, explicamos detalladamente la intuición matemática de la criptografía de retículos, comenzando con la definición geométrica de los retículos, seguido de la formulación del problema LWE, hasta la construcción de la criptografía de clave pública.

Un Retículo (Lattice) es un espacio discreto representado por combinaciones lineales con coeficientes enteros de vectores base, y en altas dimensiones resulta difícil encontrar una “buena base” casi ortogonal (SVP).
El Problema LWE (Learning With Errors) es un problema de resolver sistemas de ecuaciones lineales con ruido, y dado que esto está ligado a la dificultad del problema del retículo en el peor de los casos, proporciona una base sólida para la seguridad.
Utilizando el problema LWE, el cifrado y descifrado (Criptografía de Regev) se logran mediante un ingenioso mecanismo que intencionalmente añade y elimina el ruido.
En los protocolos reales, se emplean Ring-LWE o Module-LWE usando anillos de polinomios para aumentar la eficiencia de comunicación y la velocidad de cálculo, sirviendo como la base del estándar ML-KEM del NIST.

Con el cambio de paradigma computacional sin precedentes que representan las computadoras cuánticas acercándose, es muy fascinante que la “criptografía de retículos”, nacida del abismo del álgebra lineal clásica y la teoría de números, se convierta en la base de la seguridad del internet del futuro. Las matemáticas subyacentes a la criptografía de retículos no son excesivamente complejas, y con conocimientos básicos de álgebra lineal y probabilidades, es perfectamente posible comprender su hermosa estructura. Esperamos que este artículo sirva de ayuda para comprender la criptografía de retículos, el núcleo de la PQC.

La Hipótesis de Riemann y la Distribución de los Números Primos: Su Profunda Relación con la Criptografía Moderna

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

1. Introducción: El misterio cósmico de los números primos y la Hipótesis de Riemann

Los “números primos” (Prime Numbers) son números naturales divisibles únicamente por 1 y por sí mismos, y también se les llama los “átomos” del mundo de las matemáticas. Esta secuencia que continúa con 2, 3, 5, 7, 11, 13… parece a primera vista aparecer de manera caótica y aleatoria. Desde que el matemático de la antigua Grecia, Euclides, demostró que “los números primos son infinitos”, innumerables matemáticos han intentado desentrañar la regularidad oculta en esta disposición de números primos.

Quien más se acercó a este misterio de los números primos fue el matemático alemán Bernhard Riemann, quien en 1859 propuso la “Hipótesis de Riemann” (Riemann Hypothesis). La Hipótesis de Riemann es uno de los problemas más importantes y no resueltos de las matemáticas modernas, y tiene una recompensa de 1 millón de dólares al ser uno de los Problemas del Milenio establecidos por el Instituto Clay de Matemáticas.

A primera vista, un problema tan difícil de matemáticas puras relacionado con la distribución de los números primos puede parecer ajeno a nuestra vida diaria. Sin embargo, la seguridad de Internet que sustenta la infraestructura de la sociedad moderna, en particular las tecnologías criptográficas modernas como la criptografía RSA y la criptografía de curva elíptica (ECC), dependen profundamente de las propiedades de los números primos gigantes.

En este artículo, emprenderemos un viaje matemático desde la distribución de los números primos, pasando por el Teorema de los Números Primos, la función zeta de Riemann, hasta llegar al núcleo de la Hipótesis de Riemann. Profundizaremos en detalle sobre cómo se relaciona con la criptografía moderna y qué sucedería en el mundo si se demostrara la Hipótesis de Riemann.

2. El Teorema de los Números Primos y la distribución de los números primos: El descubrimiento de Gauss

Para comprender cómo se distribuyen los números primos, los matemáticos consideraron la función contadora de números primos (Prime-counting function) $\pi(x)$, que representa “cuántos números primos existen menores o iguales a un cierto número $x$”.

Por ejemplo:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

El matemático prodigio de 15 años Carl Friedrich Gauss calculó tablas masivas de números primos y descubrió que la frecuencia de aparición de los números primos disminuye en proporción inversa al logaritmo natural $\ln x$. En otras palabras, conjeturó que la probabilidad de encontrar un número primo cerca de un cierto número $x$ es aproximadamente $\frac{1}{\ln x}$.

La expresión de esto utilizando integrales es la integral logarítmica (Logarithmic integral) $\text{Li}(x)$.

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

La conjetura de Gauss fue demostrada de forma independiente en 1896 por Jacques Hadamard y Charles-Jean de La Vallée Poussin, y se estableció como el Teorema de los Números Primos (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

O se expresa de manera aproximada de la siguiente forma:

$$ \pi(x) \sim \frac{x}{\ln x} $$

Gracias a este teorema, sabemos que, a nivel macroscópico, los números primos tienen una distribución muy suave y predecible. Sin embargo, a nivel microscópico, siempre existe un “error” o “fluctuación” entre $\pi(x)$ y $\text{Li}(x)$. La verdadera naturaleza de esta fluctuación es exactamente el mayor misterio que la Hipótesis de Riemann intenta desentrañar.

3. La función zeta de Riemann y el producto de Euler

El arma más poderosa para analizar la distribución de los números primos es la función zeta de Riemann (Riemann Zeta Function). Originalmente fue una serie infinita definida por Leonhard Euler para números reales $s > 1$.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

Uno de los mayores logros de Euler fue demostrar que esta serie infinita podía expresarse como un producto infinito sobre todos los números primos $p$. Este es el producto de Euler (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

Una comprensión intuitiva de la demostración es que si expandimos cada término del lado derecho como una serie geométrica y los multiplicamos, gracias al teorema fundamental de la aritmética (todo número natural se puede expresar de forma única como el producto de números primos), se reconstruye completamente la suma de los recíprocos de los números naturales en el lado izquierdo.

Esta única fórmula se convirtió en el puente que conecta el análisis matemático (series infinitas y funciones continuas) y la teoría de números (números primos y números discretos). Estudiar la función zeta es sinónimo de estudiar la distribución de los números primos.

4. Continuación analítica y la extensión al plano complejo

La genialidad de Riemann radica en haber extendido la variable $s$ de $\zeta(s)$, que Euler había considerado únicamente para números reales, a números complejos $s = \sigma + it$ ($\sigma$ es la parte real, $t$ es la parte imaginaria).

La serie infinita original converge solo para $\sigma > 1$, pero Riemann utilizó una técnica llamada “continuación analítica” (Analytic Continuation) para extender la definición de manera que $\zeta(s)$ tenga sentido en todo el plano complejo, excluyendo el polo en $s = 1$.

Además, dedujo una hermosa ecuación funcional (Functional equation) que satisface la función zeta.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Donde $\Gamma(x)$ es la función gamma. A través de esta ecuación, podemos conocer las propiedades del semiplano izquierdo a partir de las propiedades del semiplano derecho.

Ceros de la Función Zeta (Zeros of the Zeta Function)

Los números complejos $s$ para los cuales el valor de la función zeta se vuelve 0 se denominan “ceros”. A partir de la ecuación funcional, cuando $s$ es un número par negativo ($-2, -4, -6, \dots$), dado que $\sin(\pi s / 2)$ se vuelve 0, se tiene $\zeta(s) = 0$. Estos se conocen como ceros triviales (Trivial zeros).

Sin embargo, lo que es importante para la distribución de los números primos son los otros ceros, es decir, los ceros no triviales (Non-trivial zeros) que existen en la “banda crítica” (Critical strip) donde $0 \le \sigma \le 1$.

5. El núcleo de la Hipótesis de Riemann y la fórmula explícita

Riemann calculó unos pocos ceros y formuló una conjetura sorprendente. Esta es la Hipótesis de Riemann.

Hipótesis de Riemann (Riemann Hypothesis) Todos los ceros no triviales de la función zeta de Riemann $\zeta(s)$ se encuentran en la línea recta donde la parte real es igual a $1/2$ ($\text{Re}(s) = 1/2$).

A esta recta donde la parte real es 1/2 se le llama la “línea crítica” (Critical line).

graph TD A["Función zeta de Riemann ζ(s)"] --> B["Extensión al plano complejo mediante continuación analítica"] B --> C["Ceros triviales (s = -2, -4, -6 ...)"] B --> D["Ceros no triviales (0 <= Re(s) <= 1)"] D --> E["Hipótesis de Riemann"] E --> F["Todos los ceros no triviales están en Re(s) = 1/2"] F --> G["Hacia la demostración del límite del término de error de la distribución de primos"]

¿Por qué es tan importante la Hipótesis de Riemann? Porque los ceros de la función zeta determinan completamente la distribución de los números primos.

Riemann y el posterior matemático von Mangoldt derivaron una “fórmula explícita” (Explicit formula) que describe con precisión la distribución de los números primos. Utilizando la función de Chebyshev $\psi(x)$, se expresa de la siguiente manera:

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Aquí, $\rho$ es la suma sobre todos los ceros no triviales de la función zeta. El término principal es $x$ (que corresponde al Teorema de los Números Primos), y al sumar y restar los términos ondulatorios que dependen de los ceros $\rho$, se restaura la distribución precisa en forma de escalera de los números primos. Se puede decir que los ceros no triviales representan la “frecuencia (onda)” de la distribución de los números primos.

Si la Hipótesis de Riemann es correcta y la parte real de todos los ceros no triviales $\rho$ es exactamente $1/2$, entonces el término de error del Teorema de los Números Primos se mantendrá dentro del rango mínimo teóricamente concebible.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

En otras palabras, si la Hipótesis de Riemann es verdadera, se demuestra que los números primos están distribuidos de la manera más “regular y hermosa” que podamos imaginar.

6. La relación inseparable entre la criptografía moderna y los números primos

Hasta aquí hemos estado en el profundo mundo de las matemáticas puras, pero las propiedades de estos números primos sostienen desde sus cimientos a la sociedad digital moderna. El principal representante de esto es la criptografía de clave pública, liderada por la criptografía RSA.

La seguridad de todas las comunicaciones, como los pagos con tarjeta de crédito en Internet, la transmisión de contraseñas y las firmas digitales de blockchain, depende de los “números primos”.

Funcionamiento de la criptografía RSA

La seguridad de la criptografía RSA se basa en el hecho matemático de que “la factorización en números primos de números compuestos de muchos dígitos es extremadamente difícil” (el problema de la factorización de enteros).

Generación de claves: Se eligen aleatoriamente dos números primos gigantes, $p$ y $q$ (por ejemplo, de 2048 bits cada uno). Se multiplican para calcular $N = p \times q$. Este $N$ se convierte en parte de la clave pública. Utilizando la función indicatriz de Euler $\phi(N) = (p-1)(q-1)$, se genera la clave privada $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Cifrado y descifrado: El texto plano $M$ se transforma en el texto cifrado $C$ utilizando la clave pública $e, N$.
$$ C \equiv M^e \pmod{N} $$
Solo quien posee la clave privada $d$ puede descifrarlo.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Texto plano (Plaintext)"] --> B["Cifrado con clave pública (e, N)"] B --> C["Texto cifrado (Ciphertext)"] C --> D["Descifrado con clave privada (d)"] D --> E["Texto plano original"] F["Atacante (Attacker)"] -- "Intenta la factorización prima de N" --> C F -.-> G["Si p y q son desconocidos, d es incalculable"]

Para romper la criptografía RSA, es necesario encontrar los números primos originales $p$ y $q$ a partir del enorme $N$ (factorización prima). Incluso utilizando los algoritmos convencionales actuales (como la criba general del cuerpo de números: GNFS, por sus siglas en inglés), factorizar un número de cientos de dígitos tomaría un tiempo que supera con creces la edad del universo, incluso utilizando supercomputadoras.

7. El impacto de la Hipótesis de Riemann en la criptografía

Entonces, ¿cómo se cruzan la “Hipótesis de Riemann”, que se encuentra en la cima de las matemáticas puras, y la “criptografía”?

7.1. Algoritmos de generación de números primos (test de primalidad) y la Hipótesis Generalizada de Riemann (GRH)

Para operar la criptografía RSA, primero es necesario generar los primos gigantes $p$ y $q$. Sin embargo, no es fácil determinar de manera segura y rápida si “un número es primo o no”.

Actualmente, lo que se utiliza de forma práctica es un algoritmo probabilístico llamado el test de primalidad de Miller-Rabin (Miller-Rabin primality test). Este algoritmo es rápido, pero conlleva el riesgo de identificar incorrectamente un número compuesto como primo con una probabilidad extremadamente baja (un “pseudoprimo”).

Sin embargo, si asumimos como cierta la “Hipótesis Generalizada de Riemann” (Generalized Riemann Hypothesis, GRH), que extiende la Hipótesis de Riemann a las funciones L de Dirichlet, la historia cambia drásticamente. Si la GRH es verdadera, se garantiza matemáticamente un límite superior en el número de pruebas en el test de Miller-Rabin, elevándolo de un algoritmo probabilístico a un “algoritmo determinista de tiempo polinómico” (este era un hecho crucial conocido incluso antes de que se descubriera el test de primalidad AKS).

En otras palabras, la Hipótesis de Riemann (y sus generalizaciones) desempeña el papel de otorgar una garantía directa a la creación de los cimientos de la criptografía: “si es posible generar números primos gigantes a gran velocidad y con absoluta confianza”.

7.2. Relación con los algoritmos de factorización

A la hora de evaluar la complejidad computacional de los algoritmos de quienes intentan descifrar la criptografía (como la criba general del cuerpo de números), también es indispensable el conocimiento sobre la distribución de los números primos. Muchos algoritmos de factorización dependen de la distribución de “números lisos” (Smooth numbers: números que solo tienen factores primos pequeños).

Para evaluar rigurosamente con qué frecuencia aparecen los números lisos, se requiere una profunda comprensión de la distribución de los números primos, y es aquí donde también se emplean técnicas de teoría analítica de números que están directamente vinculadas a la función zeta y a la Hipótesis de Riemann. Si se demuestra la Hipótesis de Riemann y se determina completamente el error en la distribución de los números primos, también será posible identificar de manera más precisa los límites de rendimiento de los algoritmos de factorización en números primos.

8. Si se demuestra la Hipótesis de Riemann, ¿se romperá la criptografía?

A veces se cuenta como una leyenda urbana que “si se resuelve la Hipótesis de Riemann, la criptografía RSA colapsará en un instante”, pero esto es matemáticamente inexacto.

La demostración de la Hipótesis de Riemann en sí misma no produciría inmediatamente un algoritmo mágico que acelere drásticamente la factorización de números primos. Esto se debe a que la Hipótesis de Riemann es simplemente un teorema sobre la “regularidad de la distribución macroscópica” de los números primos, y no nos indica directamente qué números primos dividen a un número particular $N$ (propiedad local).

Sin embargo, el impacto no es nulo. Existe una probabilidad extremadamente alta de que, en el proceso de demostrar la Hipótesis de Riemann, se descubran “nuevas herramientas matemáticas” y “métodos analíticos desconocidos”. Si observamos la historia, cuando se demostró el Último Teorema de Fermat o la Conjetura de Poincaré, las nuevas teorías desarrolladas en el proceso hicieron avanzar enormemente a todas las matemáticas.

Si se establecen métodos desconocidos de geometría algebraica o geometría no conmutativa que puedan manipular por completo las propiedades de los ceros de la función zeta de Riemann, no se puede descartar la posibilidad de que conduzcan al descubrimiento de algoritmos de factorización innovadores (por ejemplo, algoritmos clásicos que reduzcan la complejidad computacional a tiempo polinómico). En ese sentido, los criptógrafos nunca pueden quitarle los ojos de encima al progreso de la Hipótesis de Riemann.

Las computadoras cuánticas y el algoritmo de Shor

Una amenaza más directa y realista para la criptografía no es la demostración de la Hipótesis de Riemann, sino las computadoras cuánticas. El “algoritmo de Shor”, publicado por Peter Shor en 1994, demostró que si existiera una computadora cuántica con suficiente capacidad, la factorización en números primos podría resolverse en tiempo polinómico. Con esto, la criptografía RSA y la criptografía de curva elíptica quedarían fundamentalmente rotas.

Actualmente, en todo el mundo se está promoviendo la transición hacia la “criptografía post-cuántica (Post-Quantum Cryptography, PQC)” (como la criptografía basada en retículos), que no puede ser descifrada ni siquiera por computadoras cuánticas. La tecnología criptográfica que depende de los números primos puede, en cierto sentido, estar llegando al final de su edad de oro, pero el valor matemático de los números primos en sí mismos nunca se perderá.

9. Conclusión: La intersección entre la abstracción matemática y la sociedad real

graph TD A["Búsqueda en las matemáticas puras"] --> B["Resolución de la Hipótesis de Riemann"] B --> C["Comprensión completa de la distribución de números primos"] C --> D["Desarrollo espectacular de la teoría de números y geometría algebraica"] D -.-> E["Posibilidad de nuevos algoritmos de factorización prima"] E -.-> F["Actualización de la evaluación de seguridad de la criptografía"] A --> G["Matemáticas aplicadas e informática"] G --> H["Mejora en la eficiencia del test de primalidad y generación criptográfica"] H --> F

La incansable búsqueda sobre los números primos que continúa desde la antigua Grecia fue sublimada en una hermosa sinfonía sobre el plano complejo (los ceros de la función zeta) por un genio llamado Riemann. Y sorprendentemente, ese cristal de matemáticas puras y puristas se está aplicando, siglos después, como el escudo más fuerte para garantizar la seguridad de la sociedad de Internet.

La Hipótesis de Riemann es una entidad que simboliza simultáneamente la “belleza abstracta” que poseen las matemáticas y su “asombrosa aplicabilidad al mundo físico y a la sociedad real”.

Cuando esta gigantesca montaña matemática, a cuya cima aún nadie ha llegado, sea conquistada algún día, comprenderemos por completo la verdad cósmica de los números primos, y al mismo tiempo obtendremos una nueva perspectiva sobre los cimientos de la sociedad de la información. Aprender sobre criptografía es, de hecho, un viaje que recorre la historia de la sabiduría de la humanidad.

Algoritmo rápido de prueba de primalidad implementado en C++ (método de Miller-Rabin, etc.)

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

Introducción: ¿Por qué es necesaria una prueba rápida de primalidad?

En el mundo de las ciencias de la computación, la criptografía y la programación competitiva, determinar rápida y precisamente “si un número es primo o no” es un problema muy importante y fundamental. Por ejemplo, la criptografía de clave pública como el cifrado RSA, que respalda la seguridad de la sociedad de internet moderna, basa su seguridad en la generación de números primos enormes y la dificultad de su multiplicación (la dificultad de la factorización de enteros). Por lo tanto, no es exagerado decir que la tecnología para identificar instantáneamente si un número enorme es primo o no es la tecnología que sostiene los cimientos de la sociedad digital.

Además, en la programación competitiva (como AtCoder o Codeforces), la prueba de primalidad es un tema frecuente. Para una entrada enorme con restricciones como $N \le 10^{18}$, en situaciones donde se deben realizar decenas de miles de pruebas de primalidad en menos de un segundo, los algoritmos tradicionales e ingenuos simplemente no alcanzarían el tiempo de cálculo (Time Limit Exceeded: TLE).

En este artículo, comenzaremos con algoritmos ingenuos de prueba de primalidad, pasaremos a la prueba probabilística de primalidad conocida como “Prueba de Fermat”, y luego explicaremos exhaustivamente el “Test de primalidad de Miller-Rabin”, un algoritmo de alta velocidad de nivel práctico que supera sus debilidades. Cubriremos todo, desde los antecedentes matemáticos hasta implementaciones altamente optimizadas en C++. En particular, para enteros de 64 bits ($N < 2^{64}$), no solo nos limitaremos a una prueba probabilística, sino que también explicaremos detalladamente un método que “puede determinar la primalidad con 100% de certeza (prueba determinista)” y proporcionaremos un código fuente en C++ listo para usar en la práctica.

1. Fundamentos de la prueba de primalidad y el método de división por tentativa (Trial Division)

Un número primo (Prime number) es un número natural mayor o igual a 2 que no tiene divisores positivos aparte de 1 y él mismo. Siguiendo estrictamente la definición de número primo, para determinar si un entero $N$ es primo, se puede intentar dividir $N$ por todos los enteros desde $2$ hasta $N-1$. Si no se puede dividir de forma exacta por ninguno, se considera primo; si se divide de forma exacta al menos una vez, es un número compuesto (no primo).

Sin embargo, este método tiene una complejidad computacional de $O(N)$, y cuando $N$ es un número enorme como $10^{18}$, incluso las computadoras modernas tardarían una cantidad enorme de tiempo en calcularlo.

Optimización de la división por tentativa: Búsqueda hasta $\sqrt{N}$

Cuando un número compuesto $N$ se expresa como $a \times b = N$ (donde $a \le b$), siempre se cumple que $a \le \sqrt{N}$. Por lo tanto, el bucle para la prueba de primalidad no necesita repetirse hasta $N-1$; es suficiente verificar hasta $\sqrt{N}$.

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


#include <iostream>

// Prueba de primalidad usando división por tentativa (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // Solo verificar números impares mayores o iguales a 3
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

La complejidad computacional de este algoritmo es $O(\sqrt{N})$. Si $N \le 10^{12}$, se puede calcular instantáneamente, pero si $N \approx 10^{18}$, el número de iteraciones del bucle será de aproximadamente $10^9$. Incluso en C++, esto puede tomar desde cientos de milisegundos hasta varios segundos, lo que lo hace inadecuado para múltiples pruebas.

2. Prueba de Fermat: El comienzo de la prueba probabilística de primalidad

Para superar los límites del método de división por tentativa, se idearon “Algoritmos probabilísticos (Probabilistic Algorithm)” utilizando teoremas de la teoría de números. Un ejemplo representativo es la “Prueba de Fermat (Fermat Primality Test)”, que utiliza el pequeño teorema de Fermat.

Pequeño teorema de Fermat (Fermat’s Little Theorem)

Este teorema, descubierto por Pierre de Fermat, afirma lo siguiente:

Para cualquier número primo $p$ y cualquier entero $a$ que sea coprimo con $p$ (que no sea un múltiplo de $p$), se cumple la siguiente congruencia:
$$ a^{p-1} \equiv 1 \pmod p $$

Tomando la contrapositiva de este teorema, se puede decir que “si para algún entero $N$ y un entero $a$ coprimo con $N$, $a^{N-1} \not\equiv 1 \pmod N$, entonces $N$ es definitivamente un número compuesto”. Utilizando esta propiedad, la prueba de Fermat elige una base aleatoria (base) $a$ para el número a probar $N$, y verifica si $a^{N-1} \pmod N$ es igual a $1$.

Exponenciación modular rápida (Exponenciación binaria)

Para llevar a cabo la prueba de Fermat, es necesario calcular rápidamente potencias enormes como $a^{N-1} \pmod N$. Para esto, se utiliza el método de “exponenciación binaria (Modular Exponentiation / Binary Exponentiation)”. La complejidad computacional se convierte en $O(\log N)$, lo cual es muy rápido.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Cálculo de a^b mod m usando exponenciación binaria
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

※ Para evitar el desbordamiento, aquí se usa la extensión GCC/Clang __int128_t (entero de 128 bits) para mantener el producto intermedio.

Pseudoprimos y números de Carmichael (Carmichael Numbers)

La prueba de Fermat es muy poderosa, pero tiene una debilidad fatal. Resulta que existen números $N$ que son compuestos, pero para los cuales $a^{N-1} \equiv 1 \pmod N$ se cumple para todos los $a$ ($a$ coprimos con $N$).

A estos números se les llama “pseudoprimos absolutos” o “números de Carmichael”. 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, no se puede realizar una prueba determinista “100% segura” utilizando solo la prueba de Fermat. No importa cuántas $a$ diferentes se prueben, números como el $561$ siempre simularán ser primos (engañarán a la prueba).

3. Test de primalidad de Miller-Rabin (Miller-Rabin Primality Test)

La debilidad de la prueba de Fermat (la existencia de los números de Carmichael) fue superada brillantemente por el “Test de primalidad de Miller-Rabin”, ideado por Gary L. Miller y Michael O. Rabin. En la actualidad, como un algoritmo rápido y práctico de prueba de primalidad, es el más ampliamente utilizado en las bibliotecas internas de varios lenguajes de programación y en la generación de claves para sistemas criptográficos.

Principio matemático

El algoritmo de Miller-Rabin, además del pequeño teorema de Fermat, utiliza la propiedad de que “en el cuerpo residual módulo un primo ($\mathbb{Z}/p\mathbb{Z}$), las soluciones de $x^2 \equiv 1 \pmod p$ están restringidas a $x \equiv 1$ o $x \equiv -1$” (si el módulo es un número compuesto, pueden existir otras raíces cuadradas no triviales además de estas).

Para un número impar $N$ a evaluar, restar $1$ da como resultado $N-1$, que siempre es par. Entonces, dividimos $N-1$ por $2$ tantas veces como sea posible y lo expresamos en la siguiente forma:

$$ N-1 = d \cdot 2^s $$

(donde $d$ es impar, $s \ge 1$)

Para cualquier base $a$ ($1 < a < N-1$), verificamos si $a^{N-1} \equiv 1 \pmod N$ según el pequeño teorema de Fermat, pero realizamos ese cálculo paso a paso. Específicamente, repetimos el cuadrado secuencialmente como $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$.

La condición para que la prueba de Miller-Rabin determine que $N$ es “primo (o muy probablemente primo)” es que se cumpla al menos una de las siguientes condiciones:

$a^d \equiv 1 \pmod N$
Existe algún $r$ ($0 \le r < s$) tal que $a^{d \cdot 2^r} \equiv -1 \pmod N$. ※ En la operación módulo de C++, $-1 \pmod N$ se convierte en $N-1$.

Si $N$ es primo, esta condición siempre se cumplirá para cualquier $a$. Por el contrario, si $N$ es compuesto, al elegir un $a$ aleatorio, se ha demostrado matemáticamente que la probabilidad de que se cumpla esta condición (probabilidad de ser engañado) es menor o igual a $\frac{1}{4}$. Si se realizan $k$ pruebas independientes, la probabilidad de un falso positivo se vuelve $\left(\frac{1}{4}\right)^k$ o menor, lo que en la práctica puede considerarse cero. No existen números que “puedan engañar siempre”, como los números de Carmichael.

Flujo del algoritmo del método Miller-Rabin (Diagrama de flujo Mermaid)

El siguiente diagrama muestra el flujo lógico de una sola prueba del test de primalidad de Miller-Rabin (para una base $a$).

graph TD Start["Inicio de la prueba (Entrada: N, a)"] --> CalcDS["Calcular d (impar) y s tal que N-1 = d * 2^s"] CalcDS --> CalcX["Calcular x = a^d mod N"] CalcX --> CheckX1{"¿x == 1 o x == N-1 ?"} CheckX1 -- "Sí" --> ReturnTrue["Puede ser primo (Probably Prime)"] CheckX1 -- "No" --> LoopStart["Iniciar bucle desde r = 1 hasta s-1"] LoopStart --> LoopCondition{"¿r < s ?"} LoopCondition -- "No" --> ReturnFalse["Definitivamente compuesto (Composite)"] LoopCondition -- "Sí" --> SquareX["Calcular x = (x * x) mod N"] SquareX --> CheckXMinus1{"¿x == N - 1 ?"} CheckXMinus1 -- "Sí" --> ReturnTrue CheckXMinus1 -- "No" --> CheckXOne{"¿x == 1 ?"} CheckXOne -- "Sí" --> ReturnFalse CheckXOne -- "No" --> LoopNext["Incrementar r en 1 y continuar"] LoopNext --> LoopCondition

4. Prueba determinista para enteros de 64 bits

El test de primalidad de Miller-Rabin es inherentemente un algoritmo “probabilístico”, pero cuando el límite superior de $N$ es fijo, se puede realizar una prueba “100% determinista” probando un conjunto específico de múltiples bases $a$. A esto se le llama Test de Miller-Rabin Determinista (Deterministic Miller-Rabin Test).

Investigaciones realizadas por Jim Sinclair y otros han demostrado que, para todos los enteros $N < 2^{64}$ (aproximadamente $1.8 \times 10^{19}$), es posible lograr una determinación suficiente y completamente determinista probando los siguientes $7$ primos como la base $a$.

Lista de bases $a$ a probar: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

Alternativamente, como otro conjunto bien conocido, usando los siguientes $12$ primos también se puede determinar perfectamente para $N < 2^{64}$. {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

En este caso, para mejorar la simplicidad y confiabilidad del algoritmo, adoptaremos un enfoque basado en los últimos $12$ primos (o bases optimizadas a $7$). En la implementación en C++, optimizaremos para mantener el número de pruebas al mínimo dividiendo el rango con ramificación condicional.

5. Implementación avanzada en C++ (Highly Optimized C++ Implementation)

Ahora, consolidaremos la teoría matemática y el diseño del algoritmo hasta este punto y presentaremos el código de implementación de una de las funciones de prueba de primalidad de Miller-Rabin más robustas en el C++ moderno.

Puntos de la implementación

Evitar desbordamientos en la multiplicación de enteros de 64 bits: Cuando $N \approx 10^{18}$, $x \times x$ en la multiplicación modular puede ser hasta $10^{36}$, lo cual desborda fácilmente el valor máximo de $1.8 \times 10^{19}$ de los enteros de 64 bits típicos (uint64_t o long long). Para resolver este problema, utilizamos el tipo extendido __int128_t (o unsigned __int128) de GCC o Clang para calcular con precisión de 128 bits antes de aplicar el módulo. Esto permite multiplicaciones modulares rápidas sin recurrir a algoritmos complejos.
Selección de base determinista: Optimizamos para que, si el valor de $N$ es pequeño, solo se prueben unas pocas bases.

Código fuente completo en C++

A continuación, se muestra la versión completa del código fuente lista para usar en la práctica. Este código se puede copiar y usar tal cual en entornos de programación competitiva.

 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


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// (a * b) mod m rápido usando enteros de 128 bits
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// Cálculo de (base^exp) mod m mediante exponenciación binaria
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// Prueba determinista de enteros de 64 bits usando el test de primalidad de Miller-Rabin
bool is_prime_miller_rabin(uint64_t n) {
 // Casos base y comprobaciones previas para números primos pequeños
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // Descomponer en la forma n-1 = d * 2^s
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // Lista de bases a utilizar para la prueba
 // Optimización para minimizar la cantidad de bases probadas según el tamaño de N
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 7 bases que hacen que la prueba sea determinista para todo N < 2^64
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // Ejecutar la prueba para cada base
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // Si a es un múltiplo de n, no se puede determinar, pero no es primo

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // Pasa la primera condición, a la siguiente base

 bool composite = true;
 // Bucle de s-1 iteraciones (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // Pasa la segunda condición, posible primo
 break;
 }
 }

 // Si no cumple ninguna condición, es definitivamente un número compuesto
 if (composite) return false;
 }

 // Si pasa las condiciones para todas las bases, es definitivamente primo
 return true;
}

int main() {
 // Casos de prueba de muestra
 vector<uint64_t> test_cases = {
 1000000007, // Primo famoso
 998244353, // Primo famoso
 1000000000000000003, // Primo alrededor de 10^18
 1000000000000000007, // Compuesto (10^18 + 7)
 561, // Número de Carmichael (compuesto)
 18446744073709551557ULL // Uno de los primos más grandes cerca de 2^64
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

6. Complejidad del algoritmo y evaluación de rendimiento

Consideraremos el rendimiento del algoritmo implementado.

Complejidad temporal (Time Complexity)

División por tentativa: $O(\sqrt{N})$
Prueba de Fermat: Cálculo de potencia $O(\log N) \times k$ ($k$ es el número de pruebas)
Método de Miller-Rabin: Cálculo de potencia y bucle $O(\log N) \times k$

En un entorno de 64 bits ($N \le 2^{64}$), el método determinista de Miller-Rabin anterior verifica un máximo de $7$ bases. Por lo tanto, $k \le 7$ puede considerarse constante, y la complejidad de tiempo total es estrictamente $O(\log N)$. Incluso en el peor de los casos ($N \approx 10^{19}$), el número de pasos de ejecución se reduce a un máximo de $7 \times 64 = 448$ operaciones básicas, y el tiempo de ejecución es inferior a unos pocos microsegundos ($10^{-6}$ segundos). Comparado con el método de división por tentativa de $O(\sqrt{N})$ (iteraciones del bucle $\approx 4 \times 10^9$), se logra una aceleración de millones de veces.

Mayor optimización: Multiplicación de Montgomery (Montgomery Multiplication)

En la implementación de este artículo, la división (operación de módulo %) se realiza utilizando el tipo extendido de enteros de 128 bits __int128_t. Incluso en las CPU modernas, la división de enteros (instrucción DIV) es una operación costosa que requiere decenas de ciclos en comparación con la suma o la multiplicación.

Los creadores de bibliotecas y los programadores competitivos que buscan la optimización extrema a veces adoptan una técnica llamada Multiplicación de Montgomery (Montgomery Multiplication). La multiplicación de Montgomery es un algoritmo asombroso que reemplaza la costosa operación de módulo (división) por “solamente desplazamientos de bits y multiplicaciones” al mapear números en un “espacio de Montgomery” especial. Al integrar esto en la multiplicación modular de la prueba de Miller-Rabin, es posible aumentar aún más la velocidad de ejecución de dos a tres veces. Como este es un tema muy profundo, me gustaría explicarlo con más detalle en otro artículo.

7. Resumen

En este artículo, hemos explicado todo sobre las pruebas de primalidad, desde los conceptos básicos hasta el contenido avanzado. Repasemos los puntos principales.

El método de división por tentativa es seguro, pero debido a su complejidad computacional $O(\sqrt{N})$, carece de viabilidad práctica cuando $N$ supera $10^{12}$.
La prueba de Fermat es muy rápida con $O(\log N)$, pero tiene una debilidad fatal, ya que puede ser engañada por pseudoprimos absolutos como los números de Carmichael.
El test de primalidad de Miller-Rabin es el algoritmo práctico más robusto que resuelve las debilidades de la prueba de Fermat.
En la implementación en C++, utilizar __int128_t permite manejar de forma segura los desbordamientos de multiplicación de enteros de 64 bits.
Dentro del rango de enteros de 64 bits ($N < 2^{64}$), al elegir $7$ o $12$ números primos específicos como base, es posible una prueba de primalidad determinista (100% precisa) en lugar de probabilística.

La prueba de primalidad rápida es una tecnología ineludible en el cálculo con números gigantes. El código fuente de C++ de Miller-Rabin proporcionado en este artículo es lo suficientemente robusto como para ser utilizado en la práctica. Asegúrate de usarlo en tus propios proyectos y en competencias algorítmicas.

graph LR TrialDivision["División por tentativa (O(√N))"] --> Fermat["Prueba de Fermat (O(log N), tiene debilidades)"] Fermat --> MillerRabin["Método Miller-Rabin (O(log N), puede ser determinista)"] MillerRabin --> Montgomery["+ Multiplicación de Montgomery (aceleración por factor constante)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

El mundo de los algoritmos donde se cruzan la programación y las matemáticas es sumamente hermoso y profundo. Espero que este artículo te haya ayudado en tu aprendizaje continuo.

Reference:

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

¿Qué es el cifrado totalmente homomórfico (FHE)? Explicación de la clave de la seguridad de próxima generación

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

A medida que la computación en la nube y la tecnología de IA se establecen como la base de la sociedad, la compensación entre la “privacidad de los datos” y la “utilización de los datos” se ha convertido en uno de los problemas más importantes. Aunque existe una demanda creciente para que la IA en la nube analice datos altamente confidenciales como datos médicos, información financiera e información biométrica personal, muchas empresas dudan en enviar datos externamente debido a preocupaciones de seguridad.

Las tecnologías de cifrado tradicionales (como AES y RSA) son excelentes para proteger los datos almacenados en disco (Data at Rest) y los datos que fluyen por la red (Data in Transit). Sin embargo, cuando el servidor realiza un procesamiento (cálculo) en los datos, como una búsqueda o aprendizaje automático (Data in Use), es necesario descifrar el cifrado y devolverlo a texto plano. Si el servidor es hackeado en este momento de descifrado, o si un administrador malicioso interno husmea en los datos, esto conduce directamente a una fuga de información.

La tecnología soñada para superar esta debilidad fundamental del “descifrado durante el procesamiento” es el Cifrado Totalmente Homomórfico (Fully Homomorphic Encryption: FHE). Al usar FHE, es posible realizar cálculos en datos mientras permanecen cifrados, sin descifrarlos en absoluto, y devolver solo el texto cifrado resultante al cliente.

En este artículo, explicaremos en profundidad el FHE, la clave de la seguridad de próxima generación, desde el concepto y la historia del FHE, el avance revolucionario de Craig Gentry, los fundamentos matemáticos (como Ring-LWE), el mayor desafío del “ruido” y su solución (bootstrapping), hasta las bibliotecas de implementación más recientes.

1. ¿Qué es el cifrado homomórfico? Conceptos básicos

“Homomórfico” es un término en álgebra que se refiere a la propiedad de mapear entre conjuntos con una determinada estructura preservando la estructura de las operaciones. En criptografía, la “propiedad homomórfica” es la propiedad de que las operaciones en el espacio de texto plano corresponden a operaciones en el espacio de texto cifrado.

Expresado en una fórmula matemática simple, sean $m_1$ y $m_2$ los textos planos, $E(\cdot)$ la función de cifrado y $D(\cdot)$ la función de descifrado. Si la operación (como suma o multiplicación) en el texto plano es $\circ$ y la operación en el texto cifrado es $\diamond$, se cumple la siguiente relación:

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

En otras palabras, el resultado de aplicar alguna operación $\diamond$ a los textos cifrados $E(m_1)$ y $E(m_2)$ y luego descifrarlo coincide con el resultado de operar los textos planos originales con $\circ$.

Flujo de datos en la computación en la nube

La arquitectura del procesamiento en la nube usando FHE es completamente diferente a la tradicional. La siguiente figura muestra el flujo de procesamiento de datos seguro utilizando FHE.

El servidor recibe los datos cifrados $E(x)$, pero como no tiene la clave privada, le es absolutamente imposible conocer el contenido de los datos. Sin embargo, al utilizar las propiedades del FHE, es posible aplicar una función $f$ (por ejemplo, un modelo de inferencia de aprendizaje automático) al texto cifrado y generar $E(f(x))$. El cliente recibe esto y lo descifra con su propia clave privada para obtener el resultado deseado $y = f(x)$.

2. Historia de la evolución del cifrado homomórfico: PHE, SHE, FHE

El cifrado homomórfico no alcanzó su forma “completa” actual de una sola vez. Se clasifica a grandes rasgos en tres etapas dependiendo de los tipos y el número de operaciones que se pueden realizar.

Cifrado Parcialmente Homomórfico (PHE)

El PHE es un esquema de cifrado que permite un número ilimitado de operaciones de suma o multiplicación, pero solo una de las dos. De hecho, los cifrados con esta propiedad han existido durante mucho tiempo.

Cifrado RSA (Propiedad homomórfica para la multiplicación) El cifrado RSA posee de forma no intencionada una propiedad homomórfica para la multiplicación. Dados los textos planos $m_1, m_2$ y la clave pública $(e, N)$: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ Al multiplicarlos juntos: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ De esta manera, la multiplicación de textos cifrados corresponde a la multiplicación de textos planos.
Cifrado Paillier (Propiedad homomórfica para la suma) El cifrado Paillier, inventado en 1999, posee una propiedad homomórfica para la suma. Se ha puesto en práctica en sistemas como la votación electrónica (donde los votos cifrados se suman y solo se descifra el resultado final).

Cifrado Algo Homomórfico (SHE)

Es un esquema que puede ejecutar tanto sumas como multiplicaciones, pero tiene un límite en el número de operaciones (profundidad del circuito). Debido a la acumulación de “ruido”, que se explicará más adelante, el descifrado se vuelve imposible después de realizar un cierto número de multiplicaciones. El cifrado BGN (Boneh-Goh-Nissim) de 2005 es un ejemplo de esto, pero tenía limitaciones para realizar cálculos complejos prácticos (como el aprendizaje profundo).

Cifrado Totalmente Homomórfico (FHE)

Es un esquema de cifrado que permite ejecutar tanto sumas como multiplicaciones un número ilimitado de veces. De manera similar a la integridad de Turing en la teoría de la información, si la suma (equivalente a XOR) y la multiplicación (equivalente a AND) se pueden combinar infinitamente, significa que, en principio, cualquier función o algoritmo computable puede ejecutarse mientras permanece cifrado.

El FHE fue llamado durante mucho tiempo el “Santo Grial de la criptografía”, e incluso se decía que podría ser imposible de lograr. Sin embargo, en 2009, Craig Gentry, que entonces era estudiante de doctorado en la Universidad de Stanford, propuso el primer esquema FHE basado en redes ideales (Ideal Lattices), sorprendiendo al mundo.

3. Fundamentos matemáticos del FHE: El problema LWE y Ring-LWE

Muchos de los esquemas FHE principales actuales se basan en el problema LWE (Learning With Errors), que es un problema matemático complejo en la “Criptografía basada en retículos (Lattice-based Cryptography)”, también conocida como Criptografía Post-Cuántica (Post-Quantum Cryptography).

Comprensión intuitiva del problema LWE

Resolver un sistema de ecuaciones lineales es fácil si se utiliza, por ejemplo, la eliminación de Gauss.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

Pero, ¿qué pasaría si agregamos un pequeñísimo “error aleatorio (ruido)” $e$ a los resultados de estas ecuaciones?

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

El solo hecho de agregar este error $e$ transforma el problema de encontrar el vector de variables secretas $\vec{s}$ en un problema NP-difícil que es extremadamente complicado de resolver, incluso utilizando supercomputadoras actuales o computadoras cuánticas. Este es el problema LWE.

El problema Ring-LWE (RLWE)

El problema LWE estándar involucra operaciones con matrices, lo que tenía el problema de que el tamaño de la clave era muy grande (a veces en gigabytes) y la eficiencia computacional era pobre. Para solucionar esto, se introdujo el problema Ring-LWE (RLWE), que utiliza operaciones sobre anillos de polinomios.

En RLWE, los elementos pertenecen a un anillo de polinomios $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ (donde $N$ es una potencia de 2 y $q$ es el módulo primo). Si tomamos como clave privada un polinomio $s(x)$, y generamos un polinomio aleatorio $a(x)$ y un pequeño polinomio de ruido $e(x)$, la clave pública será el siguiente par:

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

Durante el cifrado, las propiedades de estos polinomios se utilizan para codificar el texto plano $m(x)$ y generar el texto cifrado.

4. El mayor obstáculo: El “ruido” y el bootstrapping de Gentry

El concepto más importante para comprender el FHE es la “gestión del ruido”.

En los cifrados basados en LWE/RLWE, se incluye intencionalmente un pequeño “ruido (error)” para garantizar la seguridad. El proceso de descifrado del texto cifrado $c$ para obtener el texto plano $m$ puede representarse a grandes rasgos mediante la siguiente fórmula:

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

Durante el descifrado, este noise (ruido) se elimina mediante procesos como el redondeo para obtener el texto plano correcto $m$. Sin embargo, cuando se realizan operaciones homomórficas (especialmente multiplicaciones) entre textos cifrados, este ruido se amplifica drásticamente.

Suma homomórfica: El ruido aumenta de forma aditiva ($e_1 + e_2$). Este es un aumento relativamente leve.
Expresión matemática de la propiedad homomórfica para la suma: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
Multiplicación homomórfica: El ruido explota de forma multiplicativa (ya que incluye términos como $e_1 \times e_2$). Después de unas pocas multiplicaciones, el ruido excede el umbral $q/2$, lo que impide un redondeo correcto y hace que el descifrado falle.
Expresión matemática de la propiedad homomórfica para la multiplicación: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

Esta es la razón por la que el FHE no se pudo realizar durante mucho tiempo y se mantuvo en el nivel de SHE (limitado en operaciones).

La magia del Bootstrapping

La contribución genial de Craig Gentry fue la invención de una técnica de reducción de ruido llamada “bootstrapping”. Esto fue un cambio de paradigma en la criptografía.

Intuitivamente, es una operación de “limpiar el texto cifrado ‘descifrándolo’ mientras permanece en estado cifrado, antes de que se corrompa por estar lleno de ruido, y colocarlo en un nuevo texto cifrado”.

Supongamos que hay un texto cifrado con mucho ruido $C_{noisy}$.
El cliente proporciona previamente al servidor su clave privada $sk$ “cifrada con su clave pública” $E_{pk}(sk)$ (a esto se le llama clave de bootstrapping).
El servidor ejecuta un circuito de descifrado (Decryption Circuit) de forma homomórfica sobre $C_{noisy}$.
Específicamente, realiza un “descifrado en el espacio cifrado” sobre $E_{pk}(C_{noisy})$ utilizando $E_{pk}(sk)$.
Dado que este circuito de descifrado es en sí mismo una operación homomórfica, genera nuevo ruido, pero el ruido del nuevo texto cifrado resultante $C_{fresh}$ se restablece a un “nivel fijo” constante.

graph LR A["Texto cifrado con alto ruido C_noisy"] --> B["Circuito de descifrado homomórfico (Eval_Dec)"] C["Clave privada cifrada E(sk)"] --> B B --> D["Texto cifrado con bajo ruido C_fresh"] style B fill:#ffeeba,stroke:#ffc107

Al ejecutar regularmente este bootstrapping durante el cálculo, en teoría se hizo posible calcular circuitos de profundidad infinita (logrando el FHE). Sin embargo, en el esquema original de Gentry, este proceso de bootstrapping tenía un costo computacional desesperadamente alto, tardando de decenas de minutos a horas por cada ejecución.

5. Generaciones de FHE y evolución de los esquemas principales

En busca de la aplicación práctica del FHE, criptógrafos de todo el mundo han estado compitiendo para mejorar los algoritmos. Actualmente, el FHE se clasifica principalmente en cuatro generaciones o familias.

2ª Generación: Operaciones exactas con enteros (BGV, BFV)

Estos son los esquemas BGV (Brakerski-Gentry-Vaikuntanathan) y BFV (Brakerski/Fan-Vercauteren) que aparecieron entre 2011 y 2012. Se basan en RLWE y son adecuados para la aritmética modular de enteros (cálculos exactos). Soportan técnicas de procesamiento por lotes (Batching) similares a SIMD (Single Instruction, Multiple Data), lo que permite empaquetar miles de ranuras de datos dentro de un solo texto cifrado polinomial gigante y realizar cálculos en paralelo a la vez.

3ª Generación: Aceleración del bootstrapping (GSW, FHEW, TFHE)

El esquema GSW (Gentry-Sahai-Waters) de 2013 simplificó aún más la estructura del FHE. Un desarrollo basado en esto es el TFHE (Fast Fully Homomorphic Encryption over the Torus), que es una de las opciones principales en la actualidad. La característica del TFHE es que su bootstrapping es extremadamente rápido (en el orden de milisegundos). Es fuerte en operaciones a nivel de puertas (circuitos lógicos como AND, XOR) y tiene un tamaño de texto cifrado relativamente pequeño, por lo que es adecuado para evaluar rápidamente circuitos lógicos arbitrarios.

4ª Generación: Especialización en cálculos aproximados y aprendizaje automático (CKKS)

El esquema CKKS (Cheon-Kim-Kim-Song), propuesto por Cheon et al. en 2017, es la tecnología definitiva para la protección de la privacidad en la IA y el aprendizaje automático actuales. Mientras que las versiones anteriores de FHE se centraban en “cálculos de enteros exactos”, el CKKS admite “cálculos aproximados de números de coma flotante” mientras los datos permanecen cifrados. Muestra un rendimiento abrumador en cálculos de números reales donde se permiten pequeños errores, como el entrenamiento y la inferencia de redes neuronales.

La siguiente tabla resume cómo elegir un esquema según su propósito.

Nombre del Esquema	Tipo de datos preferido	Casos de uso recomendados	Características
BFV / BGV	Enteros (Integer)	Cálculos estadísticos exactos, agregación de datos financieros, búsquedas en bases de datos	Alto rendimiento a través del procesamiento por lotes SIMD
CKKS	Números reales (Real/Complex)	Aprendizaje automático (DNN, regresión logística), procesamiento de señales	Aceleración mediante cálculos aproximados, reescalado
TFHE	Valores booleanos (Boolean)	Circuitos lógicos arbitrarios, búsqueda de cadenas, evaluación de funciones no lineales	Bootstrapping ultrarrápido (en milisegundos)

6. Práctica: Bibliotecas FHE y código conceptual

Actualmente, existen muchas bibliotecas de código abierto disponibles que permiten usar el FHE sin requerir un conocimiento profundo en criptografía.

Microsoft SEAL (Simple Encrypted Arithmetic Library): Biblioteca en C++ que admite BFV, BGV y CKKS. Es uno de los estándares de la industria. Su enlace en Python, TenSEAL, es popular entre los ingenieros de IA.
Zama (Concrete): Un framework basado en TFHE. Puede escribirse en Rust/Python y ofrece la capacidad de compilar modelos PyTorch existentes para ejecutarlos sobre FHE (Concrete ML).
OpenFHE: Sucesor de PALISADE, es una biblioteca integral en C++ que soporta todos los esquemas principales.

Ejemplo de programación FHE usando Python (TenSEAL)

Aquí presentamos un ejemplo de código conceptual en Python usando el esquema CKKS para sumar y multiplicar vectores de números reales mientras se mantienen cifrados.

 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


import tenseal as ts

# 1. Configuración del contexto (incluye generación de claves)
# Usando el esquema CKKS, establecer el grado del polinomio en 8192
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # Factor de escala para números reales

# 2. Lado del cliente: Cifrado de datos
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# Convertir vectores de texto plano a texto cifrado (normalmente ejecutado en el lado del cliente)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. Lado del servidor: Operaciones con datos cifrados (Protección de Data in Use)
# El servidor no conoce el texto plano, pero puede realizar sumas y multiplicaciones
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. Lado del cliente: Descifrado de los resultados
# Solo el cliente que posee la clave privada puede ver los resultados
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"Resultado de la suma descifrado: {res_add}")
# Ejemplo de salida: [3.5000001, 5.5000001, 7.5000002] (Contiene un ligero error debido al cálculo aproximado)

print(f"Resultado de la multiplicación descifrado: {res_mul}")
# Ejemplo de salida: [3.0000002, 7.5000005, 14.0000003]

Como se puede ver en el código anterior, los operadores normales de Python como enc_v1 + enc_v2 están sobrecargados, lo que permite escribir cálculos entre textos cifrados de forma muy intuitiva. En el lado del servidor, las operaciones con vectores se completan sin conocer su contenido.

7. Desafíos del FHE: Rendimiento y aceleración de hardware

Aunque el FHE proporciona una seguridad teóricamente perfecta, el mayor desafío en su implementación práctica es la “sobrecarga de rendimiento (overhead)”.

Sobrecarga computacional: Comparado con los cálculos en texto plano, los cálculos en texto cifrado son de miles a decenas de miles de veces más lentos en una CPU. La multiplicación de polinomios y el bootstrapping requieren cálculos masivos de FFT (Transformada Rápida de Fourier) o NTT (Transformada Teórica de Números).
Expansión del tamaño de los datos (Ciphertext Expansion): Unos pocos bytes de texto plano pueden convertirse en megabytes una vez cifrados. Esto ejerce una fuerte presión sobre el ancho de banda de la memoria y la red.

Enfoques para soluciones a través del hardware

Para superar esta sobrecarga, se están desarrollando en todo el mundo aceleradores de hardware dedicados al FHE (con soporte para ASIC, FPGA y GPU).

Aceleración por GPU: Se están realizando esfuerzos para paralelizar las operaciones NTT y el bootstrapping utilizando potentes GPUs como las de NVIDIA, habiéndose reportado velocidades decenas de veces mayores en comparación con las implementaciones por software (por ejemplo, 100x.ai, el backend CUDA de TFHE-rs de Zama).
Proyecto DARPA DPRIVE: La Agencia de Proyectos de Investigación Avanzados de Defensa de EE. UU. (DARPA) está promoviendo el proyecto de desarrollo de hardware dedicado “DPRIVE (Data Protection in Virtual Environments)” para llevar la velocidad de cálculo del FHE a un nivel equivalente al de procesamiento de texto plano (dentro de un margen de sobrecarga de 10 veces), con la participación de Intel, Microsoft, Intellectual Ventures, entre otros.
La llegada de la FPU (FHE Processing Unit): Startups como Cornami y Optalysys se están embarcando en el desarrollo de chips dedicados al FHE utilizando computación óptica o arquitecturas de silicio especiales.

En un futuro cercano, puede que llegue una era en la que las “FPU” vengan integradas de serie en servidores e infraestructuras en la nube, al igual que ocurre con las NPU (Neural Processing Unit) en el campo de la IA.

8. Casos de uso esperados

A medida que el FHE se acerca a velocidades prácticas, se esperan innovaciones disruptivas en los siguientes campos:

Protección de la privacidad en análisis médicos y genómicos: Al permitir que la IA en la nube aprenda de los historiales médicos o los datos de ADN de los pacientes en poder de múltiples hospitales mientras se mantienen cifrados con FHE, es posible desarrollar modelos de diagnóstico de cáncer de alta precisión o nuevos fármacos sin violar las leyes de privacidad (como HIPAA o GDPR).
Detección de fraudes y prevención de lavado de dinero (AML) en instituciones financieras: Bancos de la competencia pueden cotejar datos entre sí de forma cifrada, sin revelar la información de las cuentas de los clientes o el historial de transacciones, lo que permite realizar análisis interbancarios para detectar enormes redes de transferencias ilícitas.
API de inferencia de IA segura (MaaS: Model as a Service): Los usuarios envían su propia voz, imágenes faciales o indicaciones (prompts) de forma cifrada a servicios de IA (como un LLM tipo ChatGPT). El proveedor de IA genera la respuesta sin conocer en absoluto los datos introducidos por el usuario y la devuelve como texto cifrado. Esto elimina por completo la preocupación de que “la IA aprenda o espíe la información personal”.

9. Conclusión: El futuro de la criptografía avanza hacia el “cálculo invisible”

Al igual que la invención de la criptografía de clave pública (RSA) en la década de 1970 hizo posible la comunicación segura en Internet (como HTTPS), la invención del FHE por parte de Craig Gentry es uno de los hitos más importantes en la historia de la criptografía.

Hoy en día, el cifrado totalmente homomórfico (FHE) ha saltado de la teoría de los laboratorios y ha entrado en una fase en la que Microsoft, IBM, Intel, Google y muchas startups compiten ferozmente por su aplicación práctica. Aunque los desafíos del coste computacional y el tamaño de los datos aún persisten, el rendimiento continúa mejorando a un ritmo que supera la Ley de Moore, gracias al refinamiento de los algoritmos y la evolución de los aceleradores de hardware.

En unos pocos años, “calcular datos mientras están cifrados” ya no será algo extraordinario, sino que se convertirá en una de las mejores prácticas estándar de protección de datos en los servicios en la nube. El FHE es verdaderamente la clave de la seguridad de la próxima generación, al materializar el equilibrio definitivo entre la privacidad y la utilización de los datos en nuestra sociedad impulsada por los datos.

Fundamentos matemáticos de la criptografía de curva elíptica (ECC) e implementación en C++

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

Fundamentos matemáticos de la criptografía de curva elíptica (ECC) e implementación en C++

En la tecnología criptográfica moderna, la criptografía de curva elíptica (Elliptic Curve Cryptography: ECC) juega un papel extremadamente importante. Desde nuestras comunicaciones diarias en Internet (HTTPS/TLS), los enclaves seguros de los teléfonos inteligentes, la autenticación de servidores mediante SSH, la autenticación sin contraseña como FIDO, e incluso en criptomonedas como Bitcoin y Ethereum, no es una exageración decir que la base de confianza de la sociedad digital moderna está respaldada por ECC.

En este artículo, explicaremos exhaustivamente con un volumen abrumador cómo funciona esta criptografía de curva elíptica, partiendo de la hermosa pero compleja teoría matemática detrás de ella (geometría algebraica sobre campos finitos), los métodos de implementación prácticos usando C++, y además, técnicas de codificación seguras para prevenir ataques de canal lateral (ataques de tiempo).

1. ¿Por qué la criptografía de curva elíptica? (Comparación con RSA)

Cuando se hablaba de criptografía de clave pública, durante mucho tiempo el sinónimo era RSA. RSA basa su seguridad en la “dificultad de factorizar números compuestos enormes”. Sin embargo, con el aumento de la capacidad computacional de los ordenadores, para mantener la seguridad ha surgido la necesidad de alargar continuamente el tamaño de la clave RSA (el número de bits del módulo). Hoy en día, se recomienda una longitud de clave de al menos 2048 bits, o 3072 y 4096 bits para mayor seguridad.

Por otro lado, la criptografía de curva elíptica (ECC) fundamenta su seguridad en una dificultad matemática diferente: el “problema del logaritmo discreto en curvas elípticas (ECDLP)”. Hasta la fecha, no se ha descubierto ningún algoritmo eficiente (como algoritmos de tiempo subexponencial) para resolver el ECDLP, e incluso los métodos de ataque más eficientes conocidos requieren un tiempo exponencial.

Debido a esta propiedad, ECC tiene la ventaja decisiva de poder lograr el mismo nivel de seguridad que RSA con una longitud de clave mucho más corta.

Nivel de seguridad (bits)	Longitud de clave RSA (bits)	Longitud de clave ECC (bits)	Proporción de longitud de clave
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Como muestra la tabla anterior, para obtener una seguridad de 128 bits (el estándar actual), RSA requiere una clave de 3072 bits, pero con ECC solo se necesitan 256 bits. Esto permite una reducción en la cantidad de cálculos, un menor uso de memoria y un ahorro de ancho de banda en la red, presumiendo de una ventaja abrumadora, especialmente en entornos con recursos limitados como dispositivos IoT y tarjetas inteligentes.

2. Preparación matemática: Teoría de grupos y el mundo de los campos finitos

Para comprender verdaderamente la criptografía de curva elíptica, es necesario dominar los conceptos básicos del álgebra abstracta (teoría de grupos y teoría de campos). Aquí resumiremos de manera concisa los conocimientos previos para construir ECC.

2.1. Grupo (Group) y grupo abeliano

Un grupo (Group) es un conjunto $G$ junto con una operación binaria (aquí la asumiremos como adición $+$) en ese conjunto, denotado como $(G, +)$, que satisface los siguientes 4 axiomas:

Clausura (Closure): Para cualesquiera $a, b \in G$, se cumple que $a + b \in G$.
Asociatividad (Associativity): Para cualesquiera $a, b, c \in G$, se cumple que $(a + b) + c = a + (b + c)$.
Existencia del elemento neutro (Identity element): Existe un elemento $e \in G$ tal que para cualquier $a \in G$, $a + e = e + a = a$. En el caso de un grupo aditivo, este elemento neutro generalmente se denota como $0$ o $\mathcal{O}$.
Existencia del elemento inverso (Inverse element): Para cualquier $a \in G$, existe un elemento $b \in G$ tal que $a + b = b + a = e$. Este $b$ se denota como $-a$.

Además, si el resultado no cambia al invertir el orden de la operación, es decir, si satisface la siguiente condición, el grupo se denomina grupo abeliano (grupo conmutativo).

Conmutatividad (Commutativity): Para cualesquiera $a, b \in G$, se cumple que $a + b = b + a$.

El conjunto de puntos en una curva elíptica, al definir una regla de adición específica, forma este grupo abeliano.

2.2. Campo finito (Finite Field)

En la teoría criptográfica, no se utilizan campos con un número infinito de elementos continuos como los números reales o complejos, sino un campo finito (Finite Field) o campo de Galois (Galois Field), donde el número de elementos es finito.

El campo finito más básico es el campo primo $\mathbb{F}_p$ utilizando un número primo $p$. Esto es el conjunto de enteros $\{0, 1, 2, \dots, p-1\}$ en el que se definen las cuatro operaciones aritméticas (suma, resta, multiplicación, división) módulo $p$ (el resto de dividir por $p$).

Suma: $(a + b) \pmod p$
Resta: $(a - b) \pmod p$
Multiplicación: $(a \times b) \pmod p$
División: $a \times b^{-1} \pmod p$ (donde $b^{-1}$ es el inverso multiplicativo de $b$ módulo $p$)

El cálculo del inverso multiplicativo modular (Modular Multiplicative Inverse) es extremadamente importante en las implementaciones criptográficas. Para encontrar $b^{-1}$ que satisfaga $b \times b^{-1} \equiv 1 \pmod p$, se utilizan principalmente los dos siguientes algoritmos:

Algoritmo de Euclides extendido (Extended Euclidean Algorithm): Es rápido, pero dependiendo de la implementación, el tiempo de procesamiento puede depender de los valores de entrada, por lo que existe el riesgo de ataques de tiempo.
Pequeño teorema de Fermat (Fermat’s Little Theorem): Cuando $p$ es primo y $b \neq 0$, se cumple que $b^{p-1} \equiv 1 \pmod p$. Dividiendo ambos lados por $b$, obtenemos $b^{p-2} \equiv b^{-1} \pmod p$. En otras palabras, calculando la potencia $p-2$ de $b$, se obtiene el inverso. Dado que las operaciones de exponenciación son fáciles de implementar en tiempo constante, esta es la preferida en implementaciones criptográficas.

3. Ecuación de la curva elíptica y geometría

3.1. Forma normal de Weierstrass

Una curva elíptica (Elliptic Curve) es una curva plana generalmente definida por la siguiente ecuación, llamada forma normal de Weierstrass (Weierstrass normal form).

$$ y^2 = x^3 + ax + b $$

Aquí, $a$ y $b$ son constantes, y como condición para que la curva no tenga puntos singulares (auto-intersecciones o cúspides), es decir, para que sea una curva suave, se requiere que el siguiente discriminante (Discriminant) $\Delta$ no sea cero.

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

Dado que una curva con puntos singulares compromete la seguridad criptográfica, siempre se eligen coeficientes $a, b$ que satisfagan esta condición.

3.2. Punto en el infinito (Point at Infinity)

Para convertir matemáticamente la curva elíptica en un grupo completo, además de los puntos en el plano, introducimos un punto virtual llamado “punto en el infinito (Point at Infinity)”. Lo denotamos como $\mathcal{O}$.

El punto en el infinito $\mathcal{O}$ se define como el punto donde todas las líneas verticales se cruzan en el infinito infinito. En la teoría de grupos, este punto en el infinito $\mathcal{O}$ funciona como el elemento neutro en la adición (cero).

Es decir, para cualquier punto $P$ en la curva, se cumple lo siguiente:

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

Además, el inverso $-P$ del punto $P = (x, y)$ se define como el punto simétrico con respecto al eje x, $(x, -y)$. Por lo tanto:

$$ P + (-P) = \mathcal{O} $$

4. Operaciones de grupo en la curva elíptica (Suma de puntos y duplicación)

El núcleo de la criptografía de curva elíptica es la operación de “suma (Addition)” entre puntos de la curva. Esta difiere de la suma habitual de números enteros y se define basándose en operaciones geométricas.

4.1. Suma geométrica (Tangent and Chord Method)

El procedimiento para sumar dos puntos diferentes $P$ y $Q$ en la curva para obtener un nuevo punto $R$ ($R = P + Q$) es el siguiente:

Se traza una línea recta (cuerda) que pasa por los puntos $P$ y $Q$.
Esta línea recta siempre interceptará la curva elíptica en un tercer punto (a este lo llamaremos $-R$). (*Según un teorema de la geometría algebraica)
El punto obtenido al reflejar el punto de intersección $-R$ simétricamente sobre el eje x (invirtiendo el signo de la coordenada y) será el punto $R$ buscado.

graph TD Step1["Trazar una línea que conecte P(x1, y1) y Q(x2, y2)"] --> Step2["Encontrar el tercer punto de intersección -R con la curva"] Step2 --> Step3["Reflejar -R sobre el eje x para obtener R(x3, y3)"] Step3 -.-> Result["Esto es R = P + Q"]

4.2. Duplicación de puntos (Point Doubling)

Al sumar el mismo punto $P$ a sí mismo ($P + P = 2P$), no se puede trazar una línea que pase por dos puntos. En este caso, se traza la línea tangente (Tangent) a la curva en el punto $P$.

Se traza la línea tangente a la curva en el punto $P$.
Esta línea tangente interceptará la curva en un segundo punto $-R$.
El punto reflejado simétricamente sobre el eje x será el punto buscado $R = 2P$.

4.3. Fórmulas de cálculo algebraico

Las operaciones geométricas se traducen a fórmulas algebraicas para que puedan ser calculadas por un ordenador. Todas las operaciones se realizan sobre el campo finito $\mathbb{F}_p$ (módulo $p$).

Sean el punto $P = (x_1, y_1)$ y el punto $Q = (x_2, y_2)$. Además, el punto resultante del cálculo será $R = P + Q = (x_3, y_3)$.

Sea $\lambda$ (lambda) la pendiente de la recta.

[Caso 1: Cuando $P \neq Q$ (Suma de puntos)] La pendiente $\lambda$ es la tasa de cambio entre los dos puntos.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

Usando este $\lambda$, $x_3, y_3$ se calculan de la siguiente manera:

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[Caso 2: Cuando $P = Q$ (Duplicación de puntos)] La pendiente $\lambda$ es la pendiente de la recta tangente obtenida por diferenciación. (Se deriva implícitamente $y^2 = x^3 + ax + b$)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

Por lo tanto,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

Las fórmulas para $x_3, y_3$ tienen la misma forma que en la suma, pero como $x_2 = x_1$, se convierten en:

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] Estas fórmulas incluyen divisiones (cálculo del inverso modular), como $(x_2 - x_1)^{-1}$ y $(2y_1)^{-1}$. Dado que el cálculo del inverso modular tiene un costo computacional muy alto, en las implementaciones reales generalmente se utilizan sistemas de coordenadas proyectivas que retrasan la división, como las “Coordenadas Jacobianas (Jacobian Coordinates)”.

5. Multiplicación escalar y el problema del logaritmo discreto en curvas elípticas (ECDLP)

En la criptografía de curva elíptica, la operación con mayor costo computacional y que forma el núcleo de la seguridad es la multiplicación escalar (Scalar Multiplication).

5.1. ¿Qué es la multiplicación escalar?

La operación de sumar un punto $P$ un número $k$ de veces se llama multiplicación escalar y se denota como $kP$.

$$ kP = \underbrace{P + P + \dots + P}_{k\text{ veces}} $$

Aquí, $k$ es un número entero muy grande (por ejemplo, un entero de 256 bits).

5.2. Problema del logaritmo discreto en curvas elípticas (ECDLP)

La seguridad de la criptografía de curva elíptica depende de la dificultad del siguiente problema.

Problema del logaritmo discreto en curvas elípticas (Elliptic Curve Discrete Logarithm Problem: ECDLP) Dado un punto conocido $P$ (punto base) y el punto resultante $Q$, encontrar el escalar $k$ que satisfaga $Q = kP$.

Calcular $Q$ a partir de $k$ y $P$ (dirección directa) es fácil (tiempo polinomial) utilizando el algoritmo descrito a continuación, pero calcular $k$ inversamente a partir de $P$ y $Q$ (dirección inversa) no tiene una solución eficiente aparte de una búsqueda exhaustiva (fuerza bruta), lo que lo hace virtualmente imposible (función unidireccional). En los protocolos criptográficos, $k$ corresponde a la “clave privada” y $Q$ a la “clave pública”.

5.3. Algoritmo Double-and-Add (Doble y Suma)

Cuando $k$ es un número enorme (por ejemplo: $2^{256}$), sumar ingenuamente $P$ un total de $k$ veces no terminaría ni siquiera si se agotara la vida del universo. Por lo tanto, para realizar la multiplicación escalar a alta velocidad, se utiliza el método Double-and-Add (método binario).

Esta es la versión de curva elíptica del método de “cuadratura repetida” para calcular potencias de enteros de manera rápida. Expresa el escalar $k$ en formato binario y lo procesa secuencialmente desde el bit más significativo.

Inicializar el punto $R$ que mantiene el resultado con $\mathcal{O}$.
Repetir lo siguiente desde el bit más significativo de $k$ hasta el menos significativo:
- Duplicar $R$ (Point Doubling: $R = 2R$)
- Si el bit actual es 1, sumar $P$ a $R$ (Point Addition: $R = R + P$)

Gracias a este algoritmo, la complejidad computacional se reduce drásticamente de $O(k)$ a $O(\log_2 k)$, permitiendo cálculos en un tiempo realista (cuestión de milisegundos).

6. Intercambio de claves de curva elíptica Diffie-Hellman (ECDH)

Aquí explicaremos el funcionamiento del protocolo de intercambio de claves ECDH (Elliptic Curve Diffie-Hellman), que es el ejemplo de aplicación más representativo de ECC. ECDH es un mecanismo que permite a Alice y Bob generar y compartir de forma segura una clave secreta compartida (clave de sesión) sobre un canal de comunicación que podría ser espiado (es el núcleo del apretón de manos TLS).

[Parámetros preestablecidos (Parámetros de dominio)] Ambas partes comparten de antemano la curva elíptica $E$ a utilizar, el número primo $p$ y el punto base $G$. (Por ejemplo, NIST P-256 o secp256k1)

sequenceDiagram participant Alice as "Alice" participant Bob as "Bob" Note over Alice,Bob: "Parámetros públicos: Curva E, Punto base G, Primo p" Alice->>Alice: "Generar clave privada d_A (entero aleatorio)" Alice->>Alice: "Calcular clave pública Q_A = d_A * G" Bob->>Bob: "Generar clave privada d_B (entero aleatorio)" Bob->>Bob: "Calcular clave pública Q_B = d_B * G" Alice->>Bob: "Enviar clave pública Q_A (texto plano)" Bob->>Alice: "Enviar clave pública Q_B (texto plano)" Alice->>Alice: "Calcular secreto compartido S = d_A * Q_B" Bob->>Bob: "Calcular secreto compartido S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "¡Los resultados de cálculo S de ambos coinciden perfectamente!"

Un atacante (Eve) que intercepte la comunicación puede obtener $G$, $Q_A$ y $Q_B$ que fluyen por la red, pero debido a la dificultad del ECDLP, no puede deducir la clave privada $d_A$ de Alice a partir de $Q_A = d_A \cdot G$. Además, multiplicar $Q_A$ y $Q_B$ no produce la clave compartida $S$, por lo que el espía no puede calcular $S$.

7. Dificultades en la implementación: Ataques de canal lateral y contramedidas

Incluso si un algoritmo criptográfico es teóricamente perfecto, pueden surgir vulnerabilidades en el proceso de implementarlo como programa. Esto se conoce como “ataque de canal lateral (Side-Channel Attack)”.

7.1. Ataque de tiempo (Timing Attack)

Revisemos el algoritmo Double-and-Add mencionado anteriormente.

1
2
3
4
5
6
7
8


// Pseudocódigo vulnerable de Double-and-Add
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Siempre se ejecuta
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // ¡Solo se ejecuta cuando el bit es 1!
 }
}

Esta implementación tiene una falla fatal. Dado que la suma de puntos (Point Addition) se ejecuta cuando el bit es 1, el tiempo de cálculo será ligeramente mayor que cuando el bit es 0. Además, el comportamiento de predicción de bifurcaciones del procesador y la memoria caché también cambiará. Si un atacante observa estadísticamente esta diminuta diferencia en el tiempo de cálculo (o el consumo de energía) miles de veces, podría recuperar completamente la secuencia de bits de la clave privada $k$ bit por bit. Este es el ataque de tiempo.

7.2. Implementación de tiempo constante (Constant-Time): Escalera de Montgomery (Montgomery Ladder)

Para prevenir los ataques de tiempo, es necesario adoptar un algoritmo en el que la secuencia de instrucciones ejecutadas y el tiempo de cálculo sean siempre constantes (Constant-Time), independientemente del valor de los bits de la clave privada.

El ejemplo representativo de esto es la Escalera de Montgomery (Montgomery Ladder).

graph TD Start["Inicialización: R0 = O, R1 = P"] --> LoopStart["Para cada bit i (desde el más significativo)"] LoopStart --> Cond{"¿Cuál es el valor de k_i?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["Siguiente bit"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Todos los bits completados"| End["Fin: R0 es el resultado (kP)"]

Lo hermoso de la Escalera de Montgomery es que, sin importar si el bit es 0 o 1, “siempre se ejecuta una suma de puntos (Point Addition) y una duplicación de puntos (Point Doubling)”. Esto elimina por completo la dependencia de los datos en el tiempo de cálculo.

Sin embargo, si la bifurcación misma (if (k_i == 0)) sigue existiendo, aún persiste el riesgo de que el tiempo de ejecución varíe debido a las optimizaciones del compilador o la predicción de saltos de la CPU. Por lo tanto, en una implementación real de Constant-Time, las bifurcaciones condicionales (instrucciones if) se eliminan y se utiliza un intercambio condicional (Conditional Swap) empleando operaciones a nivel de bits.

8. Implementación de criptografía de curva elíptica en C++

A partir de aquí, plasmaremos la teoría en código C++. Las bibliotecas criptográficas prácticas (como OpenSSL o libsodium) utilizan optimizaciones avanzadas en ensamblador o el sistema de coordenadas jacobianas, pero aquí, para profundizar en la comprensión matemática, mostraremos la estructura de una implementación Constant-Time fácil de entender usando coordenadas afines.

Asumiremos el uso de boost::multiprecision::cpp_int para las operaciones con enteros gigantes.

8.1. Aritmética modular y el inverso

Primero, definiremos funciones de ayuda para operaciones en campos finitos. Implementaremos el cálculo del inverso modular utilizando el pequeño teorema de Fermat.

 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


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// Ejemplo usando el número primo p y parámetros de secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Operación modular que devuelve un residuo positivo
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// Exponenciación modular (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// Inverso modular usando el pequeño teorema de Fermat
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Asumiendo que m es primo: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Representación de puntos y operaciones de grupo (Suma y Duplicación)

Implementamos la estructura Point que maneja el punto en el infinito con una bandera, y las fórmulas de suma.

 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


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // Crear el punto en el infinito
 Point() : x(0), y(0), isInfinity(true) {}

 // Crear un punto normal
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Suma de puntos en la curva elíptica (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = punto en el infinito
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (Caso P = Q)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (Caso P != Q)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Implementación de intercambio condicional en tiempo constante (Constant-Time Conditional Swap)

Al intercambiar el contenido de variables basado en el valor de un bit de la clave privada, realizamos el intercambio únicamente mediante operaciones a nivel de bits (máscaras) sin utilizar sentencias if. Esto asegura que la ruta de ejecución sea completamente constante.

[!TIP] En implementaciones reales, las clases de enteros de precisión múltiple con asignación dinámica como cpp_int no son adecuadas para procesamientos de tiempo constante, ya que se filtra información de temporización mediante la asignación de memoria o variaciones en el tamaño de los arreglos. Las bibliotecas prácticas los representan con una longitud fija (por ejemplo, arreglos de 4 elementos uint64_t) e implementan el enmascaramiento a nivel de bits. El siguiente es un ejemplo conceptual.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// Constant-Time Swap conceptual (asumiendo enteros de longitud fija)
// Si el bit es 1, intercambia P1 y P2; si es 0, no los intercambia
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit es 0 o 1. La máscara es todo 1s (0xFF..) si bit=1, y todo 0s si es 0.
 // (Aquí asumimos que cada palabra de la clase BigInt de longitud fija es w para la explicación)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // Procesar de igual manera la coordenada y, así como la bandera isInfinity
 }
 */

 // * Un intercambio perfecto de tiempo constante en boost::multiprecision es difícil,
 // pero aquí lo limitaremos a simularlo mediante ramificación para comprender la lógica.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Multiplicación escalar mediante la Escalera de Montgomery

Combinamos pointAdd y cswap previamente descritos para implementar una multiplicación escalar segura.

 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


// Multiplicación escalar k * P (Método de Escalera de Montgomery)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Punto en el infinito
 Point R1 = P;

 // Obtener la longitud de bits de k (256 bits para secp256k1)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Obtener el valor del i-ésimo bit (0 o 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Si bit == 1, intercambiar R0 y R1
 cswap(R0, R1, bit);

 // Siempre se ejecuta la misma operación (Point Addition y Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Si bit == 1, volver a intercambiar para restaurar el estado original
 cswap(R0, R1, bit);
 }

 return R0;
}

Con esta lógica de implementación, sin importar si cada bit del escalar $k$ es 0 o 1, las operaciones ejecutadas dentro de la iteración de cada bucle (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) seguirán un flujo exactamente igual, previniendo fuertemente la fuga de información confidencial a través de variaciones en la temporización o los patrones de acceso a la caché.

9. Conclusión

A primera vista, la criptografía de curva elíptica (ECC) puede parecer un misterio y hacernos preguntar, “¿Cómo pueden las operaciones geométricas como trazar una línea recta y reflejar intersecciones convertirse en criptografía?”. Sin embargo, al mapearlo al mundo discreto de los campos finitos, es el producto de una fusión milagrosa entre las matemáticas y la criptografía que nos permite construir espléndidas funciones unidireccionales (problema del logaritmo discreto).

En este artículo explicamos los siguientes puntos clave:

Ventaja sobre RSA: Ofrece una seguridad robusta con longitudes de clave muy cortas, ideal para la era actual móvil e IoT.
Fundamentos de teoría de grupos y campos finitos: La estructura matemática que sirve como base para ECC.
Fórmulas de suma y duplicación: Métodos de implementación de operaciones de grupo algebraicas usando la ecuación de Weierstrass.
La amenaza de los ataques de canal lateral: Cómo las bifurcaciones condicionales que dependen de los bits de la clave privada crean vulnerabilidades fatales.
Implementación de tiempo constante (Constant-Time): Técnicas de codificación en C++ usando la Escalera de Montgomery y el Intercambio Condicional para igualar el comportamiento a nivel de hardware y prevenir ataques.

Crear por tu cuenta una biblioteca criptográfica para entornos de producción generalmente no se recomienda (“Don’t roll your own crypto”) debido a los riesgos de seguridad extremadamente altos. Sin embargo, comprender profundamente los algoritmos subyacentes y el contexto matemático puede ser una herramienta invaluable y poderosa para los ingenieros que diseñan y operan sistemas más seguros y eficientes.

En el próximo artículo, nos gustaría profundizar más en el mecanismo de ECDSA (Elliptic Curve Digital Signature Algorithm), un algoritmo de firma digital que utiliza esta curva elíptica, y en las firmas de Schnorr adoptadas en Bitcoin.

Simulé el algoritmo de Shor en Python

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

1. Introducción: La crisis de la criptografía provocada por las computadoras cuánticas

Gran parte de la seguridad en la sociedad de Internet moderna depende de la criptografía de clave pública (especialmente RSA). Cuando enviamos la información de nuestra tarjeta de crédito en compras en línea o intercambiamos datos altamente confidenciales, el contenido de esa comunicación está fuertemente protegido por la criptografía RSA.

La base de la seguridad de la criptografía RSA radica en el hecho matemático de que “la factorización de números enteros enormes es extremadamente difícil para las computadoras clásicas (las PC y supercomputadoras que usamos normalmente)”. Sin embargo, el “Algoritmo de Shor (Shor’s Algorithm)”, publicado por Peter Shor en 1994, socavó esta premisa desde sus cimientos. Se demostró matemáticamente que, si se ejecuta el algoritmo de Shor en una computadora cuántica a gran escala, la factorización de números primos, que le tomaría a una computadora clásica más tiempo que la edad del universo, puede resolverse en solo unos minutos a unas horas.

En este artículo, explicaremos exhaustiva y detalladamente cómo el algoritmo de Shor realiza la factorización de manera rápida, desde su mecanismo matemático hasta la implementación de una simulación concreta utilizando Python y el marco de computación cuántica Qiskit.

2. Cambio dramático en la complejidad computacional: De tiempo exponencial a polinómico

¿Por qué es difícil la factorización? Incluso si utilizamos la “Criba General del Campo de Números (General Number Field Sieve, GNFS)”, conocida como el mejor algoritmo de factorización en computadoras clásicas, su complejidad computacional es subexponencial.

La complejidad temporal para factorizar un número compuesto de $N$ dígitos con métodos clásicos es la siguiente:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Por lo tanto, con solo aumentar la longitud de la clave (por ejemplo, a 2048 o 4096 bits), a una computadora clásica le tomará miles o decenas de miles de años descifrarla, un tiempo que no es realista.

Sin embargo, al utilizar el algoritmo de Shor en una computadora cuántica, la complejidad computacional se reduce dramáticamente a tiempo polinómico respecto al número de bits de entrada $\log N$.

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

Esto significa que si se duplica el número de bits, el tiempo de cálculo en una computadora clásica aumentaría astronómicamente, mientras que en una computadora cuántica aumentaría como mucho unas 8 veces. Esta reducción de la clase de complejidad de tiempo exponencial a polinómico (inclusión en la clase BQP) es la verdadera grandeza del algoritmo de Shor.

graph TD A["Aumento del tamaño de entrada (número de bits) N"] --> B{"Elección del algoritmo"} B -->|Clásico: Criba General del Campo de Números| C["Aumento subexponencial O(exp(...))"] B -->|Cuántico: Algoritmo de Shor| D["Tiempo polinómico O((log N)^3)"] C --> E["Miles a miles de millones de años (Indescifrable)"] D --> F["Minutos a horas (Descifrable en tiempo realista)"]

3. Visión general del algoritmo y fundamentos matemáticos

De hecho, el algoritmo de Shor no realiza todo en la computadora cuántica. Está compuesto por una colaboración entre el preprocesamiento y posprocesamiento mediante una computadora clásica y la parte central (algoritmo de búsqueda de período) realizada por la computadora cuántica.

El flujo general del algoritmo es el siguiente:

graph TD A["Entrada: Número compuesto a factorizar N"] --> B["Elegir un número aleatorio a tal que a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Sí" --> D["Imprimir factor trivial gcd(a, N) y terminar"] C -- "No" --> E["Encontrar el período r de f(x) = a^x mod N con algoritmo cuántico"] E --> F{"¿r es par y a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Sí" --> G["Calcular factores p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Salida: p, q"]

Reducción del problema de factorización al problema de búsqueda de período

La genialidad de Shor consistió en transformar el “problema de factorización” en el “problema de búsqueda de período (Order Finding Problem)”.

Consideremos un entero $N$ (el número que queremos factorizar) y un entero $a$ coprimo con $N$ ($1 < a < N$). Definimos la siguiente función exponencial modular:

$$ f(x) = a^x \bmod N $$

Esta función tiene un cierto período $r$. Es decir, para cualquier $x$, se cumple que $f(x+r) = f(x)$. Especialmente cuando $x=0$,

$$ a^r \equiv 1 \pmod N $$

El número entero positivo más pequeño $r$ que cumple esto se llama el “orden (Order) de $a$ módulo $N$”. Si podemos encontrar este período $r$, podemos deducir los factores primos de la siguiente manera.

Transformando la ecuación,

$$ a^r - 1 \equiv 0 \pmod N $$

Si $r$ es par, se puede factorizar usando la fórmula de diferencia de cuadrados.

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Esto significa que $N$ tiene un factor común con $(a^{r/2} - 1)$ o con $(a^{r/2} + 1)$ (siempre que se cumpla la condición $a^{r/2} \not\equiv -1 \pmod N$). Por lo tanto, utilizando el algoritmo de Euclides, calculando

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

podemos encontrar los factores primos no triviales $p, q$ de $N$. Este cálculo (el cálculo del máximo común divisor y la generación de números aleatorios) se puede realizar de manera muy rápida en una computadora clásica. El problema se reduce a cómo encontrar rápidamente el período $r$. En una computadora clásica, encontrar este período $r$ en sí mismo requiere un tiempo exponencial. Aquí es donde entra en juego la computadora cuántica.

4. Parte del algoritmo cuántico: Mecanismo de búsqueda de período

La subrutina para encontrar el período $r$ utilizando una computadora cuántica consta de los siguientes cuatro pasos.

graph LR subgraph "Transición del estado cuántico" S1["|0⟩|0⟩ (Inicialización)"] --> S2["Compuerta H: Superposición Σ|x⟩|0⟩"] S2 --> S3["Oráculo U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Extracción del período por interferencia"] S4 --> S5["Medición: Obtención del valor aproximado y"] end

Paso 1: Inicialización de los registros cuánticos y superposición

Primero, preparamos dos registros cuánticos. El primer registro es para la entrada de estado, y el segundo registro es para almacenar el resultado del cálculo de la función. El estado inicial es todo $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Aplicamos la compuerta de Hadamard (Hadamard Gate) a todos los qubits del primer registro, creando un estado de superposición equiprobable de todas las entradas posibles $x$ (desde $0$ hasta $Q-1$, $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

De esta manera, la computadora cuántica mantendrá los estados de todas las $Q$ entradas simultáneamente en una sola operación. Esta es la poderosa fuente del paralelismo cuántico.

Paso 2: Aplicación de la función oráculo (exponenciación modular)

A continuación, utilizamos el circuito de operación cuántica $U_f$ para calcular la función $f(x) = a^x \bmod N$ y almacenamos el resultado en el segundo registro.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

En este punto, el primer y el segundo registro se encuentran en un estado de entrelazamiento cuántico (Entanglement). Si (hipotéticamente) observáramos el segundo registro y obtuviéramos un valor específico $k = a^{x_0} \bmod N$, el estado del primer registro colapsaría a una superposición de las $x$ que producen ese valor $k$. Dado que el período de la función es $r$, los estados restantes serán valores separados por $r$: $x_0, x_0+r, x_0+2r, \dots$

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Sin embargo, no queremos conocer $x_0$, sino el período $r$ en sí. Es imposible observar $r$ directamente desde este estado. Por lo tanto, utilizamos la transformada de Fourier cuántica.

Paso 3: Interferencia de fase mediante la Transformada de Fourier Cuántica (QFT)

Aplicamos la Transformada de Fourier Cuántica (Quantum Fourier Transform, QFT) al primer registro. La QFT es la versión cuántica de la transformada de Fourier discreta clásica y transforma la amplitud del vector de estado. La acción de la QFT sobre el estado base $|x\rangle$ se define de la siguiente manera:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Aquí, $\omega = e^{2\pi i / Q}$.

Al aplicar la QFT, las amplitudes de estado interfieren. Omitiendo los detalles matemáticos, cuando se aplica la QFT a un estado con período $r$, las ondas causan una interferencia constructiva (Constructive Interference) solo cuando $y$ es un valor extremadamente cercano a un múltiplo entero de $Q/r$. Para los demás estados, las amplitudes de probabilidad se anulan debido a la interferencia destructiva (Destructive Interference) y se acercan a cero.

Paso 4: Medición y expansión en fracciones continuas

Finalmente, medimos el primer registro. El valor $y$ obtenido de la medición satisfará la siguiente condición con alta probabilidad:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ es un entero desconocido tal que $0 \le c < r$)

Al aplicar el algoritmo clásico de expansión en fracciones continuas (Continued Fraction Expansion) al número racional obtenido $y/Q$, calculamos la fracción aproximada $c/r$ y extraemos el período $r$ del denominador.

5. Implementación de simulación utilizando Python y Qiskit

Dado que la teoría por sí sola puede ser difícil de visualizar, simulemos realmente el algoritmo de Shor utilizando Python y el marco de cálculo cuántico de IBM, Qiskit.

Aquí implementaremos el escenario más clásico y famoso: “factorizar $N=15$ utilizando $a=7$”.

Preparación del entorno de ejecución

Instala Qiskit de antemano.

1

pip install qiskit qiskit-aer numpy

Resumen del código de implementación en Python

El siguiente código es un ejemplo de implementación del algoritmo de Shor especializado para $N=15, a=7$. Construir un circuito de exponenciación modular de propósito general tiene un costo computacional demasiado alto para los simuladores actuales, por lo que las operaciones de las compuertas para el caso específico de $a=7$ están programadas en duro (hardcoded).

 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


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Función para construir la Transformada de Fourier Cuántica Inversa (QFT†)
def qft_dagger(n):
 """Genera un circuito de transformada de Fourier cuántica inversa de n qubits"""
 qc = QuantumCircuit(n)
 # Compuertas SWAP para invertir el orden
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Aplicación de compuertas de fase controladas y compuertas H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Función para construir la operación de exponenciación modular controlada 7^x mod 15
def c_amod15(a, power):
 """Genera una compuerta U controlada para un a específico y su potencia (exclusivo para N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Lógica de codificación dura (hardcoding) de 7^x mod 15 para el caso a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Construcción del circuito cuántico principal
def shor_circuit(a, n_count):
 # n_count: Número de bits del registro de control
 # El registro objetivo requiere 4 bits para representar de 0 a 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Inicialización del primer registro (registro de control) (generación de superposición)
 for q in range(n_count):
 qc.h(q)

 # Inicialización del segundo registro (registro objetivo) a |1> (0001)
 qc.x(3 + n_count)

 # Aplicación de la operación de exponenciación modular controlada (Oráculo)
 for q in range(n_count):
 # Aplicación de la operación elevada a la potencia 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Aplicación de la transformada de Fourier cuántica inversa al primer registro
 qc.append(qft_dagger(n_count), range(n_count))

 # Medición del primer registro
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Sección de ejecución ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Uso de 8 qubits para el registro de control (Q=256)

 print(f"Configuración de búsqueda: N={N}, a={a}, qubits de control={n_count}")

 # Generación del circuito
 qc = shor_circuit(a, n_count)

 # Ejecución en el simulador
 sim = AerSimulator()
 # Se recomienda usar transpile en las versiones recientes de Qiskit
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nResultados de medición (cadena de bits: número de observaciones):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} veces")

 # Posprocesamiento clásico: Identificación del período r mediante expansión de fracciones continuas
 print("\n--- Cálculo del período y factorización ---")
 phases = []
 for output in counts:
 # Convertir cadena de bits a número decimal
 decimal = int(output, 2)
 # Fase = valor medido / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Obtener la fracción aproximada por expansión de fracciones continuas. El límite del denominador es N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Valor observado: {decimal:3d} | Fase: {phase:.4f} | Fracción continua: {frac} | Período estimado r = {r}")

 # Comprobar si el período r es par y produce resultados válidos
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => ¡Éxito! Los factores primos de {N} son {guess1} y {guess2}.")
 else:
 print(f" => Solo factores triviales. Intentando de nuevo.")
 else:
 print(f" => Fallo porque el período es impar.")

Explicación del código y análisis de los resultados de ejecución

Al ejecutar el código anterior, como resultado de la medición del registro de control, se obtienen picos específicos (valores observados) con alta probabilidad. En el caso de n_count=8 ($Q=256$), si se trata de una computadora cuántica ideal (o un simulador), los valores observados como 0, 64, 128 y 192 aparecerán con una probabilidad abrumadora.

Si dividimos estos valores por $Q=256$, las fases $y/Q$ serán $0.0$, $0.25$, $0.5$ y $0.75$, respectivamente. Al expandir estas fases en fracciones continuas, obtenemos:

$0.25 \to 1/4$ (Período estimado $r=4$)
$0.50 \to 1/2$ (Período estimado $r=2$)
$0.75 \to 3/4$ (Período estimado $r=4$)

Utilizando el período obtenido $r=4$, calculamos los factores primos. Dado que $a=7, r=4$, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Impresionantemente, hemos tenido éxito en la factorización de $15 = 3 \times 5$.

[!TIP] Si se obtiene $y=128$ (fase $0.5$) como valor de medición, el denominador será $2$, y obtendremos un divisor del verdadero período $r=4$ en lugar del período real. En tales casos, se puede llegar al verdadero período ejecutando el algoritmo varias veces o examinando los múltiplos del $r$ obtenido.

6. Desafíos para la implementación práctica y los límites de la era NISQ

Si bien fue fácil factorizar $N=15$ en un simulador, factorizar RSA-2048 (un número decimal de 617 dígitos) utilizado en el mundo real presenta numerosos obstáculos para las computadoras cuánticas actuales.

La época en la que vivimos actualmente se llama la era NISQ (Noisy Intermediate-Scale Quantum: Cuántica de Escala Intermedia Ruidosa). Los qubits son extremadamente vulnerables al ruido ambiental y sufren “decoherencia” durante los cálculos, lo que destruye su estado.

Para ejecutar con precisión circuitos profundos (con muchas compuertas) como el algoritmo de Shor, la corrección de errores cuánticos (Quantum Error Correction), que corrige el ruido, es indispensable. Para crear un solo “qubit lógico” sin ruido, es necesario codificar miles de “qubits físicos” utilizando un código de superficie (Surface Code) u otros métodos.

Se estima que para romper la criptografía RSA de 2048 bits se requieren miles de qubits lógicos perfectos, y lograr esto requeriría una computadora cuántica tolerante a fallos (fault-tolerant) equipada con millones a decenas de millones de qubits físicos. Dado que los procesadores cuánticos más avanzados de la actualidad tienen solo unos cientos a unos pocos miles de qubits físicos, la criptografía mundial no se romperá de manera inminente.

[!WARNING] Sin embargo, existe un modelo de amenaza llamado “Store Now, Decrypt Later (Almacenar ahora, descifrar después)”. Los atacantes podrían adoptar la estrategia de almacenar masivamente comunicaciones confidenciales actualmente encriptadas en forma de datos cifrados, con el objetivo de descifrarlo todo en el momento en que se complete una computadora cuántica poderosa dentro de 10 a 20 años.

7. Transición hacia la Criptografía Post-Cuántica (PQC)

En preparación para la llegada de ese “Día Q (Q-Day)” (el día en que las computadoras cuánticas rompan la criptografía), los criptógrafos de todo el mundo, liderados por el Instituto Nacional de Estándares y Tecnología de EE. UU. (NIST), están avanzando en el desarrollo de la Criptografía Post-Cuántica (Post-Quantum Cryptography, PQC).

La PQC se basa en nuevos problemas matemáticos (problemas basados en retículos, polinomios multivariantes, funciones hash, etc.) que se consideran matemáticamente difíciles de resolver de manera eficiente incluso utilizando el algoritmo de Shor (o el algoritmo de Grover). Algoritmos como “CRYSTALS-Kyber” y “CRYSTALS-Dilithium” ya han sido seleccionados como estándares y su implementación en protocolos de comunicación para navegadores web e iMessage de Apple está comenzando gradualmente.

Para los ingenieros que gestionan la infraestructura de TI, incorporar “agilidad criptográfica (crypto-agility: la capacidad del diseño para cambiar rápidamente los esquemas criptográficos)” en sus sistemas para hacer la transición desde la actual RSA y la criptografía de curva elíptica a PQC será una misión importante en el futuro.

8. Conclusión

En este artículo, hemos proporcionado una explicación exhaustiva de aproximadamente 10,000 caracteres, que abarca desde los fundamentos teóricos y matemáticos del algoritmo de Shor hasta el mecanismo de extracción de períodos mediante la transformada de Fourier cuántica y, finalmente, un código de simulación concreto utilizando Python y Qiskit.

El hecho de que las leyes físicas del mundo microscópico de la mecánica cuántica estén subvirtiendo fundamentalmente la teoría de la complejidad computacional y la teoría de la criptografía, que son la base de la ciencia de la información macroscópica, es uno de los cambios de paradigma más emocionantes en la historia de la ciencia. No podemos quitarle los ojos de encima a las continuas batallas ofensivas y defensivas entre la tecnología de la computación cuántica, que continúa desarrollándose en tiempo real, y las nuevas tecnologías criptográficas que la enfrentan.

Te invitamos a ejecutar el código de Python presentado aquí en tu propio entorno para experimentar la “magia computacional” producida por la superposición de estados cuánticos y la interferencia.

Referencias

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【PQC Ilustrado】Comparación de los principales algoritmos de criptografía poscuántica

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

1. Introducción: La “crisis criptográfica” provocada por las computadoras cuánticas

En la sociedad de Internet moderna, la tecnología de criptografía de clave pública es una infraestructura indispensable para proteger la confidencialidad de las comunicaciones y la integridad de los datos. Los criptosistemas ampliamente utilizados en la actualidad, como RSA y la criptografía de curva elíptica (ECC), garantizan la seguridad dependiendo de barreras matemáticas como la “dificultad de factorizar números compuestos enormes” o la “dificultad del problema del logaritmo discreto sobre curvas elípticas”, respectivamente. En las computadoras clásicas (las computadoras que usamos hoy en día, incluidas las supercomputadoras), se ha demostrado que resolver estos problemas matemáticos tomaría más tiempo que la edad del universo, lo cual ha sido la base de su seguridad.

Sin embargo, esta sólida premisa está a punto de ser anulada por los avances en la teoría y aplicación práctica de la computadora cuántica. El “Algoritmo de Shor”, publicado por el criptógrafo Peter Shor en 1994, demostró teóricamente que el problema de la factorización de enteros y el problema del logaritmo discreto se pueden resolver en “tiempo polinómico” si se ejecutan en una computadora cuántica de propósito general tolerante a fallas (CRQC: Cryptographically Relevant Quantum Computer) con suficiente rendimiento. Esto significa que toda la criptografía de clave pública que se usa actualmente será inutilizada.

graph TD A["Computadora cuántica a gran escala (CRQC)"] -->|Ejecución| B["Algoritmo de Shor"] B -->|Descifrado en tiempo polinómico| C["Problema de factorización de enteros (RSA)"] B -->|Descifrado en tiempo polinómico| D["Problema del logaritmo discreto (ECC / ECDSA)"] C --> E["Intercepción de comunicaciones cifradas, manipulación de datos y suplantación de identidad"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Es muy peligroso pensar que “la finalización a gran escala de las computadoras cuánticas está a décadas de distancia, así que no hay problema”. Esto se debe a que un método de ataque llamado Store Now, Decrypt Later (SNDL: Almacenar ahora, descifrar después) ya es una amenaza real. Se trata de un ataque en el que naciones hostiles o grupos de hackers almacenan cantidades masivas de datos de comunicación cifrados actuales (como el tráfico TLS) en sistemas de almacenamiento y los descifran todos en el instante en que una potente computadora cuántica esté disponible en el futuro. Los secretos de estado, la información de infraestructuras y los datos médicos que deben protegerse a largo plazo ya están expuestos a esta amenaza.

Además, existe el Algoritmo de Grover, descubierto en 1996, contra la criptografía de clave simétrica (como AES) y las funciones hash (como SHA-256). Esto reduce a la raíz cuadrada la cantidad de cálculo para los ataques de fuerza bruta. Es decir, dado que el nivel de seguridad de AES-128 se reduce a la mitad (a 2 a la potencia de 64), se recomienda utilizar claves o longitudes de hash más largas en la era cuántica, como AES-256 o SHA-384.

Para contrarrestar esta crisis criptográfica sin precedentes, nació la Criptografía Poscuántica (Post-Quantum Cryptography: PQC), basada en nuevos problemas matemáticos que son difíciles de descifrar incluso utilizando una computadora cuántica. Basándose en los resultados del proceso de estandarización de PQC liderado por el Instituto Nacional de Estándares y Tecnología de los EE. UU. (NIST), este artículo explica detalladamente los principales algoritmos de PQC, desde sus fundamentos matemáticos hasta su funcionamiento y comparación de arquitectura.

2. Visión general e historia del proyecto de estandarización PQC por el NIST

La transición de las tecnologías criptográficas, incluyendo el rediseño de protocolos, actualizaciones de sistemas y reemplazo de hardware, toma de varios años a décadas. Por lo tanto, criptógrafos de todo el mundo han avanzado tempranamente en la investigación de PQC. El papel central lo ha desempeñado el NIST de EE. UU. En 2016, el NIST convocó un proceso de estandarización de PQC, recibiendo propuestas para algoritmos criptográficos completamente nuevos de la comunidad criptográfica mundial.

Los dos principales objetivos de estandarización fueron:

Criptografía de clave pública / Mecanismo de encapsulación de claves (KEM: Key Encapsulation Mechanism): Un mecanismo para compartir (distribuir) de forma segura claves simétricas para cifrar rutas de comunicación, como en conexiones TLS.
Firmas digitales (Digital Signatures): Un mecanismo para probar que los datos no han sido manipulados y que no hay suplantación del remitente (autenticidad) en las actualizaciones de software y certificados digitales.

Después de unos 6 años de competencia extremadamente intensa de evaluación, análisis y criptoanálisis (Ronda 1 a Ronda 3), se realizó una evaluación adicional en la Ronda 4 para algunos algoritmos. Como resultado, en 2024 los siguientes algoritmos fueron publicados formalmente como Estándares Federales de Procesamiento de Información (FIPS), estableciéndose como los futuros estándares mundiales:

FIPS 203 (ML-KEM): KEM basado en CRYSTALS-Kyber
FIPS 204 (ML-DSA): Firma digital basada en CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Firma basada en hash sin estado basada en SPHINCS+
(Programado para el futuro) FN-DSA: Firma digital basada en FALCON

Estos algoritmos seleccionados dependen de “problemas de dificultad” matemáticos diferentes. Esto asegura la diversidad (Crypto Agility) para que, incluso si se descubre una vulnerabilidad fatal en un algoritmo en el futuro, todo el sistema no colapse. En el proceso de estandarización, la criptografía basada en retículos (Lattice-based cryptography) tomó el papel principal en términos de rendimiento, pero la criptografía basada en hash y la criptografía basada en códigos fueron adoptadas como poderosos respaldos.

3. Clasificación de los principales enfoques matemáticos de PQC

Los algoritmos PQC se dividen principalmente en las siguientes cinco categorías según los problemas matemáticos que son la base de su seguridad. Este artículo profundizará especialmente en los tres primeros.

Criptografía basada en retículos (Lattice-based Cryptography): Se basa en el Problema del Vector Más Corto (SVP) y el Problema del Vector Más Cercano (CVP) en un espacio de retículo multidimensional, y el problema LWE derivado de ellos. Es el centro de la estandarización del NIST e incluye Kyber, Dilithium y FALCON. Tiene el mejor equilibrio entre velocidad de procesamiento, tamaño de clave pública y tamaño de texto cifrado, lo que lo hace adecuado para un uso general.
Criptografía basada en hash (Hash-based Cryptography): Su seguridad se basa únicamente en la “resistencia a colisiones” y la “unidireccionalidad” de funciones hash criptográficas (como SHA-2 o SHAKE). Solo es aplicable a firmas digitales (como SPHINCS+), pero su prueba de seguridad es la más robusta, caracterizándose por una resistencia extremadamente alta contra ataques matemáticos desconocidos.
Criptografía basada en códigos (Code-based Cryptography): Se basa en la teoría de códigos de corrección de errores y depende de la dificultad del Problema de Decodificación de Síndrome (Syndrome Decoding Problem). Classic McEliece, propuesto en la década de 1970, es representativo, poseyendo una historia muy larga y seguridad probada, pero el tamaño de la clave pública es extremadamente grande (en megabytes).
Criptografía de polinomios multivariables (Multivariate Polynomial Cryptography): Se basa en la dificultad de resolver sistemas de ecuaciones cuadráticas multivariables sobre un campo finito (problema MQ). Propuesto principalmente como firmas digitales (como Rainbow), pero durante la ronda final del NIST se descubrió un poderoso método de ataque que podía romperlo en unos pocos días en una sola PC, causando que muchos algoritmos quedaran fuera de la estandarización.
Criptografía basada en isogenias (Isogeny-based Cryptography): Se basa en el problema de búsqueda de caminos en grafos de isogenias de curvas elípticas. Tenía claves de tamaño muy pequeño y se esperaba que fuera el verdadero sucesor de ECC, pero su candidato final, “SIKE”, fue completamente descifrado en 2022 utilizando matemáticas clásicas (como el ataque de Castryck-Decru) en una PC ordinaria en solo unas pocas horas, un dramático final que simboliza la dificultad y el terror de diseñar PQC.

4. El abismo de la criptografía basada en retículos: Problema LWE y fundamentos matemáticos de Module-LWE

Actualmente vista como la más prometedora y el centro de la estandarización está la criptografía basada en retículos. La base de su seguridad es el problema LWE (Learning with Errors: Aprendizaje con errores). Propuesto por Oded Regev en 2005, recibió el Premio Gödel por este logro histórico. No podemos hablar del PQC moderno sin entender el problema LWE.

4.1. ¿Qué es el problema LWE (Learning with Errors)?

Primero, consideremos un sistema simple de ecuaciones lineales. Supongamos que bajo un módulo $q$ (módulo $q$), hay una matriz aleatoria conocida $A$ y un vector secreto desconocido $\vec{s}$, y se da su producto $\vec{b}$.

$$ \vec{b} = A\vec{s} \pmod q $$

En este caso, es fácil encontrar el desconocido $\vec{s}$ a partir de la información pública $A$ y $\vec{b}$. Usando el algoritmo clásico de la “eliminación de Gauss”, $\vec{s}$ puede calcularse fácilmente en tiempo polinómico.

Sin embargo, si añadimos un “pequeño error (ruido) intencional” a esta ecuación, el nivel de dificultad del problema se dispara drásticamente. Este es el problema LWE.

Preparamos un vector secreto desconocido $\vec{s} \in \mathbb{Z}_q^n$ y una matriz elegida al azar $A \in \mathbb{Z}_q^{m \times n}$. Además, preparamos un vector de error $\vec{e} \in \mathbb{Z}_q^m$ “cuyos valores de elementos son suficientemente pequeños” elegidos de acuerdo con una distribución normal o binomial, y calculamos $\vec{b}$ de la siguiente manera:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

El problema Search LWE es el problema de “encontrar la información secreta $\vec{s}$ a partir de la información pública $(A, \vec{b})$”. Debido a la existencia de este error $\vec{e}$, si se intenta usar métodos de solución algebraica como la eliminación de Gauss, el error $\vec{e}$ se amplifica exponencialmente en el proceso de sumar y restar ecuaciones, llegando a ser indistinguible de valores aleatorios y fallando por completo.

La maravilla del problema LWE es que existe una poderosa prueba teórica (reducción) de que a menos que exista un algoritmo cuántico capaz de resolver GapSVP (Problema de decisión del vector más corto) o SIVP (Problema del vector independiente más corto), que son “problemas de complejidad en el peor de los casos (Worst-case hardness)” en retículos, el problema LWE tampoco puede resolverse en el caso promedio (Average-case). Es decir, incluso para claves criptográficas generadas al azar, se garantiza una fuerte seguridad respaldada por límites teóricos.

4.2. Mejoras dramáticas en eficiencia mediante Ring-LWE y Module-LWE

El problema LWE ordinario (Standard LWE) tiene una base de seguridad muy clara, pero el tamaño de la matriz $A$ se vuelve muy grande y el tamaño de la clave se vuelve de la clase de megabytes, lo que lo hace poco práctico. Por lo tanto, se propuso el enfoque de usar Anillos Polinómicos (Polynomial Rings) para tener una estructura algebraica.

En el problema Ring-LWE, en lugar de simples vectores o matrices, se utilizan elementos (polinomios) de un cierto anillo polinómico $R_q$. En los estándares del NIST, se usa generalmente el siguiente anillo polinómico ciclotómico.

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Aquí, $n$ es una potencia de 2 (ej. 256) y $q$ es un número primo adecuado. Sobre este anillo, usando los elementos $a, s, e \in R_q$, calculamos $b = a \cdot s + e \pmod q$. Dado que un polinomio $a$ tiene $n$ coeficientes, los datos pueden comprimirse significativamente, y además, al usar la versión de campo finito de la Transformada Rápida de Fourier (FFT) llamada NTT (Number Theoretic Transform: Transformada de Teoría de Números), es posible la multiplicación ultrarrápida de polinomios con una complejidad computacional de $O(n \log n)$.

Sin embargo, había preocupaciones con Ring-LWE de que “podrían existir vulnerabilidades desconocidas debido a la estructura algebraica especial del anillo”. Además, existía un desafío de ingeniería en el que al cambiar el nivel de seguridad (equivalente a AES-128, 192, 256, etc.), el grado del polinomio $n$ en sí tenía que cambiarse, lo que requería reescribir toda la implementación como el algoritmo NTT.

Por lo tanto, los algoritmos estandarizados Kyber y Dilithium adoptaron el problema Module-LWE (M-LWE). Module-LWE es un compromiso situado justo entre el Standard LWE sin estructura y el Ring-LWE que tiene demasiada estructura, utilizando una matriz (módulo) de $k \times k$ cuyos componentes son elementos del anillo polinómico $R_q$.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

La mayor ventaja de Module-LWE es que el nivel de seguridad puede escalarse fácilmente cambiando solo la dimensión $k$ de la matriz mientras se mantiene fijo el grado del polinomio $n$ ($n=256$ en el estándar NIST). Por ejemplo, en el caso de Kyber, la dimensión $k$ se ajusta de la siguiente manera:

Kyber512 (Nivel 1): $k = 2$ (equivalente a AES-128)
Kyber768 (Nivel 3): $k = 3$ (equivalente a AES-192)
Kyber1024 (Nivel 5): $k = 4$ (equivalente a AES-256)

Esto permite que el código NTT subyacente y los circuitos de hardware para las operaciones polinómicas se reutilicen al 100% en todos los niveles de seguridad, mejorando drásticamente la seguridad y eficiencia de la implementación.

5. CRYSTALS-Kyber (ML-KEM): El mecanismo de encapsulación de claves de próxima generación

Formalmente estandarizado como FIPS 203 (ML-KEM), CRYSTALS-Kyber es un mecanismo de encapsulación de claves (KEM) basado en el problema Module-LWE antes mencionado. En el futuro, será el estándar mundial de facto para compartir claves de sesión de forma segura en TLS 1.3, SSH y otros.

5.1. Arquitectura de KEM (Key Encapsulation Mechanism)

En la era PQC, el estándar será el marco de encapsulación KEM en lugar del enfoque directo como RSA donde “el cliente crea una clave simétrica, la cifra con la clave pública del servidor y la envía”.

sequenceDiagram participant Client as "Cliente (Alice)" participant Server as "Servidor (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Generar clave privada (sk) y clave pública (pk)" Client->>Server: "Enviar clave pública (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Generar una clave simétrica aleatoria (K)" Server->>Server: "Encapsular K con pk y crear el texto cifrado (c)" Server->>Client: "Enviar el texto cifrado (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Descifrar el texto cifrado (c) usando la clave privada (sk)" Client->>Client: "Desencapsular y extraer la clave simétrica (K)" Note over Client, Server: "Iniciar la comunicación cifrada con AES, etc. usando la clave simétrica compartida (K)"

5.2. Mecanismo del algoritmo interno de Kyber y la Transformada de Fujisaki-Okamoto

El diseño de Kyber es muy refinado. Primero, construye un esquema de criptografía de clave pública (Kyber.CPAPKE) que solo es seguro contra ataques de texto plano elegido (CPA), y luego aplica un método criptográficamente muy poderoso llamado Transformada de Fujisaki-Okamoto (Fujisaki-Okamoto Transform) para actualizarlo a un KEM completo que también es seguro contra ataques de texto cifrado adaptativamente elegido (CCA).

El núcleo del mecanismo de cifrado y descifrado de CPAPKE es el siguiente:

Generación de claves (Key Generation):
- A partir de un valor semilla aleatorio, se genera una matriz $A \in R_q^{k \times k}$ en el dominio NTT. Se utiliza el módulo $q = 3329$.
- A partir de una distribución binomial centrada (CBD), se muestrean un vector secreto $\vec{s}$ y un vector de error $\vec{e}$ con coeficientes pequeños.
- Se calcula $\vec{t} = A\vec{s} + \vec{e}$. La clave pública es $(A, \vec{t})$ y la clave privada es $\vec{s}$. (En la práctica, $A$ se publica como un valor semilla para ahorrar ancho de banda).
Cifrado (Encryption):
- Se codifica el mensaje de 32 bytes (material de la clave simétrica) $m$ que se desea compartir en un polinomio.
- Se genera un nuevo vector aleatorio $\vec{r}$ y errores pequeños $\vec{e_1}, e_2$.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- El texto cifrado es $(\vec{u}, v)$.
Descifrado (Decryption):
- El receptor calcula $v - \vec{s}^T\vec{u}$.
- Expandiendo esta fórmula matemáticamente, obtenemos: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Sustituyendo $\vec{t} = A\vec{s} + \vec{e}$, el término principal $\vec{s}^TA^T\vec{r}$ se cancela.
- Lo que queda es $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Dado que los términos entre paréntesis son “productos o sumas de errores pequeños”, en conjunto siguen siendo un valor lo suficientemente pequeño (ruido). Por lo tanto, al aplicar un umbral para determinar si cada coeficiente está más cerca de $0$ o $q/2$, es posible recuperar los bits (0 o 1) del mensaje original $m$ sin ningún error.

La mayor fortaleza de Kyber es su abrumadora velocidad de procesamiento y tamaño de clave moderado. Para Kyber768, el tamaño de la clave pública es de 1,184 bytes y el tamaño del texto cifrado es de 1,088 bytes. Aunque es mayor en comparación con RSA-3072 (tamaño de clave de unos 384 bytes), puede caber dentro de la Unidad Máxima de Transmisión (MTU) de las comunicaciones modernas de Internet sin fragmentación de paquetes y casi no tiene un efecto adverso en la latencia de la red.

6. CRYSTALS-Dilithium (ML-DSA): Firma digital de propósito general basada en retículos

En la estandarización de las firmas digitales, los algoritmos con diferentes filosofías de diseño dentro del mismo enfoque de criptografía de retículos compitieron entre sí. Entre ellos, CRYSTALS-Dilithium fue seleccionado como FIPS 204 (ML-DSA) como una firma digital de propósito general.

6.1. El paradigma de Fiat-Shamir con Abortos

Dilithium, al igual que Kyber, es un esquema de firma digital basado en el problema Module-LWE (y el problema Module-SIS). Un paradigma extremadamente importante llamado “Fiat-Shamir with Aborts (Transformada de Fiat-Shamir con abortos)” se utiliza como base para su diseño.

La propia transformación de Fiat-Shamir es un método estándar para convertir un protocolo de prueba de conocimiento cero interactivo en una firma digital no interactiva. El probador (firmante) genera un compromiso $y$, calcula $w = Ay$ y lo pasa a través de una función hash para obtener un desafío aleatorio $c$, luego calcula la respuesta $z = y + cs$.

Sin embargo, si esto se aplica simplemente en la criptografía de retículos, la distribución de la respuesta $z$ se distorsiona dependiendo del valor de la clave privada $s$, lo que causaba un problema fatal donde la información sobre la clave privada $s$ se filtraría gradualmente a un atacante que observara un gran número de firmas (una fuga matemática similar a un ataque de canal lateral).

El equipo de diseño de Dilithium (Lyubashevsky et al.) introdujo una técnica llamada “Muestreo de Rechazo (Rejection Sampling)”, donde si los coeficientes del resultado de la firma $z$ no caen dentro de un rango de umbral seguro predeterminado, todo el proceso de firma es descartado (Abort) y se recalcula desde el principio usando un nuevo número aleatorio $y$.

Como resultado, la firma final $z$ que se emite se convierte en una distribución completamente uniforme independiente de la clave privada en absoluto, logrando prevenir completamente la fuga de información matemáticamente.

6.2. Ventajas y facilidad de implementación de Dilithium

La gran ventaja en el diseño de Dilithium es que no utiliza en absoluto el complejo “muestreo de la distribución gaussiana” o “cálculos de punto flotante” en el proceso de generación de firmas. Puede implementarse de forma segura y en tiempo constante (Constant-time) en una amplia gama de entornos, desde microcontroladores integrados hasta servidores en la nube, ya que solo requiere muestreo de una distribución uniforme, simples operaciones modulares de enteros, NTT y funciones hash (SHAKE). Esto lo hace muy resistente contra ataques físicos de canal lateral como los ataques de temporización.

7. FALCON (FN-DSA): Firmas de retículo ultracompactas

El NIST seleccionó FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) como otro candidato estándar de firma basada en retículos con características diferentes a Dilithium (actualmente en redacción como FN-DSA).

7.1. Retículos NTRU y muestreo gaussiano

La principal característica de FALCON es que utiliza retículos NTRU (N-th degree Truncated polynomial Ring Units), que tienen una larga historia desde 1996, en lugar del problema LWE. Además, adopta el paradigma “Hash-and-Sign (Hash y Firmar)” basado en el marco GPV (Gentry-Peikert-Vaikuntanathan).

En Hash-and-Sign, el valor hash del mensaje se utiliza como un punto objetivo en el espacio, y el punto en el retículo más cercano a ese punto (una solución aproximada del problema del vector más cercano) se encuentra para que sirva como la firma. Esto requiere muestrear puntos según una distribución gaussiana discreta, utilizando la clave privada que es una “base corta de buena calidad”.

FALCON aceleró dramáticamente este cálculo pesado usando una técnica llamada “Ortogonalización rápida de Fourier (Fast Fourier Orthogonalization: FFO)”.

7.2. Ventajas y desventajas de FALCON

La abrumadora ventaja de FALCON es que el tamaño de la firma y el tamaño de la clave pública son extremadamente pequeños (compactos). Mientras que el tamaño de la firma de Dilithium3 es de aproximadamente 3,309 bytes, el tamaño de la firma de FALCON-512 es de solo unos 666 bytes. La clave pública también es muy pequeña, 897 bytes, lo que lo convierte en un salvador en entornos donde el ancho de banda de comunicación está extremadamente restringido, dispositivos IoT o protocolos de red específicos.

Sin embargo, hay una gran desventaja. Dado que el muestreo gaussiano discreto que involucra operaciones complejas de punto flotante (64-bit IEEE 754) es obligatorio durante la generación de la firma, es extremadamente difícil lograr una implementación en tiempo constante (Constant-time implementation) para evitar fugas de temporización, y el código también se vuelve enorme. Por esta razón, FALCON se posiciona como un algoritmo especializado poderoso para propósitos específicos, en contraste con el uso general (Dilithium).

graph LR A["Requisitos de la firma digital"] --> B{"¿Cuál es la restricción principal?"} B -->|"Simplicidad de implementación, generalidad, facilidad de tiempo constante"| C["Dilithium (ML-DSA)"] B -->|"Minimización del ancho de banda y tamaño compacto de los datos"| D["FALCON (FN-DSA)"] C --> E["Certificados TLS de uso general, firmas digitales de software"] D --> F["Protocolos con estrictos límites de tamaño de paquetes, entornos especiales"]

8. SPHINCS+ (SLH-DSA): Firma basada en hash con la máxima seguridad

En preparación para el peor de los casos en el que la seguridad de la criptografía de retículos se vea comprometida por un avance matemático de genios en el futuro, el NIST formuló FIPS 205 (SLH-DSA), es decir, SPHINCS+, como un estándar con un enfoque completamente diferente a la criptografía de retículos.

SPHINCS+ está clasificado como una firma basada en hash. La base de su seguridad se basa únicamente en un punto: “que la función hash criptográfica utilizada (como SHA-2 o SHAKE256) posea resistencia a colisiones y unidireccionalidad”. Como no depende de problemas matemáticos con una estructura algebraica específica como LWE o la factorización prima, cuenta con una seguridad extremadamente fuerte (la seguridad más conservadora), en el sentido de que no importa cuán poderosos sean los algoritmos cuánticos que aparezcan en el futuro, puede contrarrestarlos simplemente extendiendo la longitud de salida de la función hash.

8.1. Arquitectura sin estado mediante WOTS+ y FORS

La historia de las firmas basadas en hash es antigua, remontándose a la firma de Lamport y la firma de un solo uso de Winternitz (WOTS) en la década de 1970. Estas eran claves desechables que “solo podían firmar de forma segura una vez”. Para hacerlas reutilizables múltiples veces, se desarrollaron algoritmos como XMSS (eXtended Merkle Signature Scheme) y LMS que combinan árboles de Merkle para gestionar innumerables claves de un solo uso con un único hash raíz.

Sin embargo, XMSS y LMS tenían el defecto grave de ser “con estado (Stateful)”. Cada vez que se realizaba una firma, el estado del índice de “qué clave de un solo uso se usó” tenía que registrarse estrictamente en la memoria no volátil, y si el estado se revertía debido a la restauración de una instantánea de máquina virtual, etc., y se usaba la misma clave de un solo uso dos veces, la clave privada se filtraría inmediatamente y el sistema colapsaría.

SPHINCS+ es una firma basada en hash “sin estado (Stateless)” que resolvió esta molestia en la gestión de estados. Su tecnología central es una combinación de lo siguiente:

WOTS+ (Winternitz One-Time Signature Plus): Una firma básica de un solo uso.
FORS (Forest of Random Subsets): Una tecnología de firma de pocas veces (Few-Time Signature). Mantiene la seguridad incluso si la misma clave se reutiliza unas cuantas veces.
Hyper-Tree (Estructura de árbol gigante): Una estructura gigantesca que superpone árboles de Merkle en múltiples capas.

En SPHINCS+, al realizar una firma, en lugar de mantener el estado, selecciona aleatoriamente una usando números pseudoaleatorios de un gran número de claves FORS en la base del Hyper-Tree para firmar. Como el número de hojas en el árbol es astronómicamente alto, la probabilidad de elegir la misma clave dos veces por accidente (colisión) es insignificantemente pequeña, lo que resulta en la realización de la falta de estado.

La única y mayor debilidad de SPHINCS+ es que su tamaño de firma es extremadamente grande. Dependiendo de los parámetros, el tamaño de la firma puede alcanzar de 17 kilobytes a 49 kilobytes, y la velocidad de generación de la firma es abrumadoramente más lenta en comparación con la criptografía de retículos. Por lo tanto, se prevé que se utilice para propósitos que no requieren firmas frecuentes y exigen una seguridad absoluta a largo plazo, como firmas de actualización de software y certificados de autoridades de certificación raíz (CA), en lugar del uso diario en la navegación web.

9. Criptografía basada en códigos: El viejo gigante Classic McEliece

En el proceso de estandarización del NIST, un enfoque importante que aún se está evaluando como candidato final de la Ronda 4 es Classic McEliece, de la criptografía basada en códigos.

Propuesto por Robert McEliece en 1978, este algoritmo es uno de los más antiguos en la historia de la criptografía de clave pública junto a RSA. Utiliza un código de geometría algebraica llamado “Código Goppa”, cifra agregando intencionalmente un error (vector de ruido) al mensaje, y se basa en el “Problema de Decodificación de Síndrome (Syndrome Decoding Problem)” donde solo aquellos con una matriz de comprobación de paridad de código Goppa como clave privada pueden eliminar el error usando una fuerte capacidad de corrección de errores y descifrar el mensaje original.

$$ \vec{c} = \vec{m} G + \vec{e} $$

($G$ es la matriz generadora codificada que es la clave pública, $\vec{e}$ es un vector de error de peso $t$)

Lo asombroso de Classic McEliece es su abrumador historial, en el que no se ha descubierto ni una sola vulnerabilidad intrínseca, a pesar de que han pasado más de 40 años desde su propuesta y de haber estado expuesto a una intensa investigación criptoanalítica por parte de criptógrafos de todo el mundo. Tiene la “fuerte seguridad probada por el tiempo” más alta entre los PQC.

Además, tiene la ventaja de que el tamaño del texto cifrado es muy pequeño (solo unos 100-200 bytes). Sin embargo, tiene el defecto fatal de que el tamaño de la clave pública se mide en megabytes (MB). Incluso en el nivel de seguridad más bajo (equivalente a AES-128), la clave pública es de unos 250 KB y supera 1 MB en niveles más altos.

Debido a esto, no es aplicable en absoluto para usos donde la clave pública se transmite a través de la red en cada comunicación, como en un handshake TLS. Sin embargo, en casos de uso especiales donde las claves públicas pueden distribuirse previamente en el sistema, como intercambios de claves precompartidas de VPN, codificación rígida de claves públicas en firmware o comunicaciones por satélite, sigue siendo evaluado como una opción extremadamente prometedora debido a su robusta seguridad.

10. Comparación de rendimiento y compensaciones de cada algoritmo PQC

Las características de rendimiento de los principales algoritmos discutidos hasta ahora, en niveles de seguridad típicos (equivalentes a los niveles 2-3 de NIST, niveles AES-128-192), se resumen en la siguiente tabla.

Algoritmo (Nombre estándar)	Categoría	Base matemática	Tamaño de clave pública	Tamaño de clave privada	Tamaño de texto cifrado/firma	Tendencia de velocidad	Características principales y usos
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	Muy rápido	El mejor equilibrio de tamaño de clave y velocidad. Estándar KEM de uso general como TLS 1.3.
Dilithium3 (ML-DSA)	Firma	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	Rápido para generar y verificar	Implementación simple. Estándar de firma digital de propósito general.
FALCON-512 (FN-DSA)	Firma	Retículo NTRU	897 Bytes	1,281 Bytes	666 Bytes	Generación algo lenta, verificación ultrarrápida	Tamaño de firma muy pequeño. Pero requiere operaciones de punto flotante. Para sistemas embebidos/IoT.
SPHINCS+ (SLH-DSA)	Firma	Función hash	32 Bytes	64 Bytes	Aprox. 17,000 Bytes	Generación muy lenta	Riesgo casi nulo de fallo matemático. Usos de alta seguridad como certificados raíz.
Classic McEliece	KEM	Código Goppa	Aprox. 1.04 MB	13,568 Bytes	188 Bytes	Encapsulación rápida	40 años de historial de seguridad. Clave pública enorme. Para entornos donde se puede codificar de forma rígida (hardcode).

Entendiendo las compensaciones

En el mundo de PQC, no existe un algoritmo único y mágico que sea “pequeño en tamaño, rápido en velocidad y perfecto en garantía matemática”.

Estándar de Internet (Kyber / Dilithium): Tienen el mejor equilibrio de rendimiento y son los más adecuados para el reemplazo directo (drop-in replacement) desde los actuales RSA/ECC.
Conservadurismo definitivo (SPHINCS+): Se elige cuando se desea un seguro absoluto contra un avance matemático en el futuro, incluso a expensas del tamaño de los datos y la velocidad de procesamiento.
Para entornos especiales (FALCON / Classic McEliece): Armas especializadas elegidas según las limitaciones del entorno, como cuando el ancho de banda de comunicación es extremadamente estrecho o cuando es posible la distribución previa.

11. Desafíos para el uso práctico y la solución realista de la “Criptografía híbrida”

Con la finalización de la estandarización por parte del NIST y la emisión formal de las especificaciones FIPS, la migración a PQC de la infraestructura de TI global (Migración PQC) ha comenzado en serio. El navegador Chrome de Google, iMessage de Apple (protocolo PQ3) y los proveedores de red como Cloudflare ya han implementado el soporte PQC en sus protocolos y han iniciado su funcionamiento real.

Sin embargo, cambiar por completo y de forma repentina a nuevos algoritmos criptográficos conlleva un riesgo muy alto. Si un matemático genial descubre un método de ataque fatal contra la criptografía de retículos como Kyber (un defecto matemático resoluble incluso por computadoras clásicas) en unos años, todo el sistema que dependa de él quedará expuesto instantáneamente.

Un enfoque realista y recomendado para mitigar este riesgo de incertidumbre es la “Criptografía híbrida (Hybrid Cryptography)”.

En la criptografía híbrida, el intercambio de claves se realiza utilizando tanto la criptografía clásica actual con un largo historial (ej., criptografía de curva elíptica como X25519) como la nueva PQC (ej., Kyber768) simultáneamente. Se genera un componente de clave simétrica de forma independiente con cada algoritmo, y finalmente se combinan los dos componentes utilizando una función de derivación de claves (KDF) segura para generar el secreto maestro final.

graph TD A["Cliente"] -->|① Enviar clave pública de X25519 + clave pública de Kyber| B["Servidor"] B -->|② Responder con clave compartida de X25519 + texto cifrado encapsulado de Kyber| A A --> C{"Derivación del secreto maestro (KDF)"} B --> C C -->|Entrada: (Clave simétrica de X25519) || (Clave simétrica de Kyber)| D["Clave de comunicación segura (AES-256 / ChaCha20)"] D -->|"Resistente tanto a amenazas cuánticas como a vulnerabilidades clásicas"| E["Comunicación segura cifrada híbrida (TLS 1.3)"]

Con esto, se logra una robusta seguridad en dos niveles: “Incluso si las computadoras cuánticas se vuelven realidad y ECC es descifrado, Kyber protege la comunicación” y, por el contrario, “Incluso si se encuentra un defecto matemático desconocido en Kyber, ECC protege la comunicación”. Un ejemplo típico es el borrador X25519MLKEM768 (anteriormente X25519Kyber768) que está siendo estandarizado por el IETF, y la comunicación entre los navegadores web actuales y los servidores de última generación se realiza utilizando precisamente este método híbrido.

Además, el concepto de Crypto Agility (Agilidad criptográfica), que consiste en construir en el diseño del sistema “una arquitectura que no dependa excesivamente de un algoritmo criptográfico específico y pueda cambiar rápidamente a otro algoritmo (por ejemplo, de Kyber a McEliece, de Dilithium a SPHINCS+) en caso de que el algoritmo falle”, se convierte en un requisito indispensable para el desarrollo de sistemas en el futuro.

12. Conclusión: Un nuevo horizonte para la tecnología criptográfica

Irónicamente, la computadora cuántica, la tecnología soñada de la humanidad, se ha convertido en la mayor amenaza para romper las barreras matemáticas del “problema de la factorización de enteros” y el “problema del logaritmo discreto” en los que hemos depositado nuestra confianza durante muchos años. Sin embargo, los criptógrafos de todo el mundo no han cedido ante esto, sino que han explorado dominios matemáticos multidimensionales más complejos y profundos como la teoría de retículos, árboles de funciones hash y códigos de corrección de errores, construyendo un nuevo muro defensivo llamado Criptografía Poscuántica (PQC).

La finalización de la estandarización de FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) y FIPS 205 (SLH-DSA) por parte del NIST no es la meta. Es solo el primer paso de un viaje épico llamado migración PQC que durará décadas. Para los ingenieros de software y arquitectos de sistemas, cómo adaptar de manera óptima “el aumento del tamaño de la clave” y el “cambio en el costo computacional” introducidos por estos nuevos algoritmos a los protocolos de red y sistemas será el gran desafío técnico del futuro.

La batalla entre las computadoras cuánticas y la criptografía es el campo emocionante donde la exploración matemática de la humanidad y la evolución de la tecnología se cruzan más intensamente. A través de este artículo, esperamos que haya comprendido profundamente la hermosa teoría matemática detrás del PQC y los sorprendentes mecanismos de cada algoritmo que darán forma al futuro de la ciberseguridad.

Referencias:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

El día en que los ordenadores cuánticos se hagan realidad: El estado actual en 2026

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

1. Introducción: En 2026, ¿hasta dónde han llegado los ordenadores cuánticos?

En la actualidad, en 2026, la computación cuántica ha experimentado un cambio decisivo de ser un antiguo “sueño teórico” a una “realidad de ingeniería”. A medida que los límites de los dispositivos NISQ (Noisy Intermediate-Scale Quantum), que eran la corriente principal hasta hace unos años, se han vuelto evidentes, las instituciones de investigación y los gigantes tecnológicos de todo el mundo han cambiado de rumbo hacia la realización de la “Computación Cuántica Tolerante a Fallos (FTQC: Fault-Tolerant Quantum Computing)”.

En este artículo, profundizaremos en el estado actual de los ordenadores cuánticos, intercalando los últimos avances de 2026. En particular, explicaremos en detalle la corrección de errores cuánticos (código de superficie), la diferencia entre cúbits físicos y lógicos, el progreso de la computación cuántica topológica y la vanguardia de los métodos superconductores y de trampa de iones.

2. Conceptos básicos del estado cuántico y la fidelidad

El cúbit (Qubit), que es la unidad básica de un ordenador cuántico, a diferencia de un bit clásico (0 o 1), puede tomar un estado de superposición (Superposition) de 0 y 1. El estado de un solo cúbit se representa como un vector en el espacio de Hilbert de la siguiente manera:

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Aquí, $\alpha$ y $\beta$ son amplitudes de probabilidad complejas y satisfacen la siguiente condición de normalización:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Una métrica extremadamente importante para medir el rendimiento de la computación cuántica es la fidelidad (Fidelity). La fidelidad $F$ entre el estado cuántico ideal $|\psi\rangle$ y la matriz de densidad real $\rho$ que se ha degradado a un estado mixto debido al ruido se define de la siguiente manera:

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

En la actualidad, en 2026, la fidelidad de las puertas de 2 cúbits (por ejemplo, las puertas CNOT o CZ) ha superado constantemente la barrera del 99,99% (los llamados “cuatro nueves”) utilizando el método superconductor. Esta es una cifra que supera con creces el umbral de corrección de errores mediante el código de superficie (aproximadamente el 99%), siendo uno de los mayores avances hacia su aplicación práctica.

3. Los límites de la era NISQ y el cambio de paradigma hacia FTQC

Desde finales de la década de 2010 hasta principios de la de 2020 fue la era de NISQ (Noisy Intermediate-Scale Quantum), dispositivos con decenas a cientos de cúbits que no tenían corrección de errores. Sin embargo, NISQ tenía límites claros.

A medida que aumenta la profundidad (Depth) del circuito, los errores se acumulan exponencialmente, lo que hace imposible obtener resultados de cálculo significativos. La probabilidad general de éxito $P_{success}$ a una profundidad de circuito $D$ decae en relación con la fidelidad $f$ de una sola puerta y el número de puertas $N$ de la siguiente manera:

$$ P_{success} \approx f^N $$

Si se aplican 1000 puertas con $f = 0.99$, resultará en $0.99^{1000} \approx 4.3 \times 10^{-5}$, y el resultado quedará casi sepultado en el ruido aleatorio. Por esta razón, en 2026, los recursos se concentran en la generación de cúbits lógicos (Logical Qubit) en lugar de escalar directamente los algoritmos NISQ (como VQE y QAOA).

4. Corrección de errores cuánticos y cúbits lógicos: La vanguardia del código de superficie

La corrección de errores cuánticos (QEC: Quantum Error Correction) es una tecnología que codifica múltiples “cúbits físicos” para crear un único “cúbit lógico” y detecta y corrige errores. Actualmente, el más prometedor es el código de superficie (Surface Code).

4.1 Estructura del código de superficie (Surface Code)

En el código de superficie, los cúbits se organizan en una cuadrícula bidimensional. Los cúbits de datos (que contienen la información real) y los cúbits de medida (para medir el síndrome) están dispuestos en un patrón de tablero de ajedrez.

graph TD A["Cúbit de datos (D1)"] --- B["Cúbit de medida (M1)"] B --- C["Cúbit de datos (D2)"] C --- D["Cúbit de medida (M2)"] D --- E["Cúbit de datos (D3)"] B --- F["Cúbit de datos (D4)"] D --- G["Cúbit de datos (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Utilizando los operadores estabilizadores $S_x$ y $S_z$, se monitorizan constantemente los cambios de bit (errores X) y los cambios de fase (errores Z).

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

Un avance significativo en 2026 es que se ha superado por completo el “punto de equilibrio (Break-even point)”. Es decir, el ruido eliminado por la corrección de errores es ahora mayor que el ruido causado por los circuitos adicionales para realizar la corrección de errores, y la vida útil del cúbit lógico supera a la del cúbit físico en varios órdenes de magnitud.

4.2 El ciclo de corrección de errores cuánticos

La corrección de errores funciona como un bucle de retroalimentación continuo.

sequenceDiagram participant D as "Cúbits de datos" participant M as "Cúbits de medida/ancila" participant C as "Controlador clásico" loop "Ciclo de extracción de síndrome (aprox. 1 microseg)" D->>M: "Entrelazar (CNOT/CZ)" M->>C: "Medir estado (Síndrome)" C->>C: "Decodificar síndrome (ej. Minimum Weight Perfect Matching)" C-->>D: "Aplicar corrección de Pauli (si es necesario)" end

Hoy en día, se ha establecido la tecnología para ejecutar este proceso de decodificación clásica (análisis del síndrome) en nanosegundos utilizando FPGAs y ASICs dedicados, y la corrección de errores en tiempo real ha entrado en la fase práctica.

5. Evolución de la arquitectura de hardware (Edición 2026)

El hardware cuántico en 2026 está evolucionando principalmente a lo largo de tres ejes: “método superconductor”, “método de trampa de iones” y “método topológico”.

5.1 Integración de cúbits superconductores

El método superconductor es un campo liderado por IBM y Google, donde predominan los cúbits transmon (Transmon) utilizando uniones Josephson. En 2026, se han hecho realidad megachips que integran entre miles y decenas de miles de cúbits físicos en un solo chip.

Lo que es especialmente destacable es el establecimiento de comunicaciones cuánticas entre módulos (Quantum Interconnects). La teleportación cuántica entre chips utilizando fotones de microondas se ha implementado a nivel comercial, permitiendo eludir las restricciones de tamaño de un solo refrigerador de dilución.

5.2 Escalado bidimensional e interconexiones ópticas de trampas de iones

El método de trampa de iones (liderado por empresas como Quantinuum e IonQ) utiliza los estados de energía internos de los iones suspendidos en el vacío como cúbits. En comparación con el método superconductor, tiene la ventaja de tiempos de coherencia T1/T2 extremadamente largos y permite conectividad de todos con todos (All-to-All Connectivity).

Los avances de 2026 son la bidimensionalización de la arquitectura QCCD (Quantum Charge Coupled Device) y la generación de entrelazamiento de alta velocidad entre múltiples trampas mediante interconexiones fotónicas. Como resultado, la “baja velocidad de las puertas” y la “escalabilidad”, que eran las debilidades de la trampa de iones, se han mejorado drásticamente.

5.3 Computación cuántica topológica: Control de anyones

La computación cuántica topológica, considerada durante mucho tiempo una existencia teórica, finalmente ha entrado en la fase de demostración experimental en 2026. Este método, promovido por empresas como Microsoft, utiliza anyones no abelianos (Non-Abelian Anyons) llamados “modos cero de Majorana (Majorana Zero Modes)”.

Las puertas cuánticas se ejecutan mediante una operación llamada “trenzado (Braiding)”, que intercambia las posiciones de las partículas de los anyones.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Donde $B_{ij}$ es el operador de trenzado. El método topológico es inherentemente resistente al ruido ambiental (tolerancia a errores a nivel de hardware) porque la preservación de la información no depende de los estados locales de las partículas, sino de la topología global de los “nudos”. En 2026, se confirmó la generación de un cúbit lógico topológico de alta fidelidad por primera vez en el mundo, atrayendo la atención como un poderoso atajo hacia FTQC.

6. Hoja de ruta y perspectivas para la aplicación práctica

Para que los ordenadores cuánticos demuestren verdaderamente la supremacía cuántica (Quantum Advantage) superando a los ordenadores clásicos (superordenadores) en “cálculos químicos”, “ciencia de materiales”, “modelado financiero”, etc., se necesitan miles de cúbits lógicos.

gantt title "Hoja de ruta de la computación cuántica (Revisada en 2026)" dateFormat YYYY axisFormat %Y section "Era NISQ" "Cúbits ruidosos (<1000)" :done, 2018, 2024 section "FTQC temprano" "Demostración del punto de equilibrio" :done, 2024, 2026 "Cientos de cúbits lógicos" :active, 2026, 2028 section "FTQC a gran escala" "1000+ Cúbits lógicos (Aplicaciones comerciales)" : 2028, 2030 "Ordenador cuántico tolerante a fallos universal" : 2030, 2035

6.1 Retos actuales y el futuro

El mayor reto en 2026 es la capacidad de enfriamiento del enorme criostato (refrigerador de dilución) para mantener temperaturas ultrabajas, y el cableado (cuello de botella de E/S) que conecta el equipo de control a temperatura ambiente con el chip cuántico a temperatura ultrabaja. En respuesta a esto, el desarrollo de chips controladores CMOS (Cryo-CMOS) que funcionan en un entorno de temperatura ultrabaja avanza a un ritmo rápido.

Conclusión

2026 será registrado en la historia de la computación cuántica como “el año inaugural del escalado de los cúbits lógicos”. Con la demostración de algoritmos de corrección de errores, la modularización del hardware y el rápido avance de los enfoques topológicos, “el día en que se vuelvan prácticos” ya no es un futuro lejano, sino que puede ser visto como un hito concreto dentro de los próximos años. Para los desarrolladores de algoritmos cuánticos y las empresas, ahora es el momento de invertir seriamente en la resolución de problemas nativos cuánticos.

Este artículo se basa en los últimos trabajos de investigación en computación cuántica y tendencias de la industria en 2026.