Saltar al contenido
El bit perdido
Newsletter

¿Cómo se esconde un secreto entre errores? El cifrado de McEliece

Nivel universidad13 min de lecturaPor Fernando Hernando

McEliece cifra con un código corrector y mete errores a propósito: solo quien conoce el código sabe quitarlos. Por qué resiste a Shor y por qué hoy se estrecha su margen.

cada dato lleva su fuente al final

El cifrado de McEliece (1978) convierte tu mensaje en una palabra de un código corrector y le añade unos cuantos errores a propósito. Quien conoce el código secreto los corrige y lee el mensaje; para cualquier otra persona, si el código está bien disfrazado, quitar esos errores es tan difícil como decodificar un código lineal cualquiera, un problema para el que no se conoce ningún algoritmo eficiente. Sobrevive a RSA en un mundo con ordenadores cuánticos porque no se apoya en factorizar, pero en 2025 y 2026 aparecieron trabajos que estrechan su margen de seguridad. Esta página cuenta cómo funciona y qué se sabe, y qué no, de esos trabajos.

La idea

Tres papeles de los códigos correctores

En esta web, los códigos correctores hacen tres cosas distintas:

  1. Proteger mensajes. Añaden redundancia para reparar daños, como en el código QR con Reed-Solomon.
  2. Esconder secretos. Es el papel de este artículo: McEliece.
  3. Proteger cúbits, en los ordenadores cuánticos, que es otra historia.

McEliece usa el mismo ingrediente que el QR, pero al revés. En el QR todo el mundo sabe cómo reparar. En McEliece solo lo sabe quien guarda la clave.

Cifrar es codificar y estropear

Un código lineal es una lista de palabras (cadenas de ceros y unos) que se describe con una matriz, la matriz generatriz: multiplicas tu mensaje por ella y sale la palabra del código. Si después se cambian algunos bits, un código bueno sabe encontrar la palabra más cercana, y así los repara.

McEliece hace esto:

  • Clave pública: una matriz que parece una matriz cualquiera, pero que genera un código que Alicia, la receptora, conoce de verdad.
  • Cifrar (Bob): codifica el mensaje con esa matriz y cambia a propósito tt bits, elegidos al azar. Esos errores son el «secreto escondido».
  • Descifrar (Alicia): como conoce la estructura oculta del código, corrige los tt errores y recupera el mensaje.
  • Espía (Eva): ve la matriz y el texto cifrado. Para quitar los errores tendría que decodificar un código lineal que, en la práctica, no sabe distinguir de uno cualquiera. En 1978, Berlekamp, McEliece y van Tilborg demostraron que la versión de decisión del problema general (dados una matriz de control, un síndrome y un número ww, ¿hay un vector de error de peso como mucho ww con ese síndrome?) es NP-completa.

Lo de «NP-completo» necesita una advertencia: describe el peor caso de un problema general, no el caso típico, y no garantiza que sea difícil romper unas claves concretas. McEliece es seguro (o no) según lo difícil que sea reconocer y deshacer el disfraz del código escogido, no solo por esa propiedad.

Claves de juguete: esta demo implementa el McEliece de 1978 con claves pequeñas y un generador pseudoaleatorio con semilla (para poder repetirlas y compartirlas). No la uses para proteger nada. Todo se calcula en tu navegador.

Parámetros y semilla

GF(16) entero como soporte; k = 8: se cifra un byte por bloque.

Cuánto detalle quieres ver

1 Genera las claves

La clave privada es un código de Goppa: un código corrector de errores que sabes decodificar deprisa. La pública es ese mismo código disfrazado para que parezca uno cualquiera, que es difícil de decodificar. Cada paso se despliega.

1.1 El cuerpo \mathrm{GF}(2^{4}) y su polinomio primitivo

Los números con los que trabajamos son los de \mathrm{GF}(2^{4}): polinomios en x con coeficientes 0 o 1, módulo el polinomio primitivo f(x) = x^{4} + x + 1. Tiene 2^{4} = 16 elementos: el 0 y las potencias \alpha^0, \dots, \alpha^{14}, donde \alpha es una raíz de f.

0 = 0000 α⁰ = 0001α = 0010α^2 = 0100α^3 = 1000α^4 = 0011α^5 = 0110α^6 = 1100α^7 = 1011α^8 = 0101α^9 = 1010α^10 = 0111α^11 = 1110α^12 = 1111α^13 = 1101α^14 = 1001

Cada elemento se escribe con 4 bits (los coeficientes de 1, x, x², …). Eso permite convertir una matriz sobre el cuerpo en una matriz binaria.

1.2 El polinomio de Goppa g(z), irreducible de grado t = 2

g(z) = z^{2} + \alpha^{9}\,z + 1. Se prueban polinomios mónicos de grado 2 al azar hasta encontrar uno irreducible (sin factores): han hecho falta 6 intentos. Irreducible garantiza que el código corrige 2 errores y que el algoritmo de Patterson funciona.

1.3 El soporte L: 16 elementos del cuerpo

L = (\alpha_0, \dots, \alpha_{15}): elementos distintos del cuerpo que no son raíces de g. Cada uno es el «nombre» de una posición del mensaje.

0 01 12 α3 α^24 α^35 α^46 α^57 α^68 α^79 α^810 α^911 α^1012 α^1113 α^1214 α^1315 α^14
1.4 La matriz de control H y su versión binaria

H = \left( \alpha_j^{\,i} / g(\alpha_j) \right)_{0 \le i < t,\quad 0 \le j < n}, de 2 filas y 16 columnas, sobre \mathrm{GF}(2^{4}). Un vector binario c está en el código si y solo si H c^{T} = 0. Cada elemento se desdobla en sus 4 bits y sale una matriz binaria H_{\text{bin}} de 8 × 16 (rango 8).

1α^6α^14α^9α^14αα^3α^3α^6α^51α^13α^9α^5α^13α
0α^61α^11α^2α^5α^8α^9α^13α^13α^9α^8α^5α^2α^111
1.5 La matriz generadora G (8 × 16)

Sus 8 filas son una base del código: k = n - \operatorname{rango}(H_{\text{bin}}) = 16 - 8 = 8 . Las columnas en verde forman un conjunto de información: ahí G es la identidad, así que el mensaje se lee directamente. Comprobación: H_{\text{bin}}\, G^{T} = 0 ✓.

1.6 El disfraz: S (invertible, 8 × 8) y P (permutación, 16 × 16)

S mezcla las filas de G (cambia de base el mismo código) y P reordena las columnas. S se elige al azar entre las matrices binarias hasta que sea invertible: 1 intento.

S

P (un 1 por fila y por columna): la fila i tiene su 1 en la columna π(i), con π = (15, 8, 14, 0, 10, 3, 12, 9, 4, 6, 1, 5, 11, 7, 2, 13)

1.7 La clave pública G′ = S · G · P

G' = S\,G\,P: sigue generando un código equivalente al de Goppa, pero ya no se ve su estructura; parece una matriz aleatoria. Es la clave pública, junto con t = 2. Ocupa 8 × 16 = 128 bits (16 bytes). La privada es (g, L, S, P).

2 Cifra un mensaje

Qué cifrar

El texto pasa a bytes (UTF-8) y se corta en bloques de 8 bits: un byte (una letra) por bloque. Cada bloque m se cifra por separado.

Bloquem (8 bits)e (peso 2)c = mG′ + e (16 bits)
010010002, 121011100100001100
011011118, 101100101010101010
011011008, 151001111111110101
011000017, 140000000011110011

Pulsa un bloque de la tabla para ver su detalle (aquí, el bloque 1 de 4) en los pasos de cifrado, descifrado y ataque.

Detalle del bloque 1

  1. El mensaje m 01001000
  2. m\,G': una palabra de tu código público 1001100100000100
  3. El error e: exactamente 2 bits a 1, en posiciones al azar (numeradas desde 0) 0010000000001000
  4. c = m\,G' + e: el texto cifrado (en rojo, los bits que el error ha cambiado) 1011100100001100

3 Descifra (con la clave privada)

Sigue el bloque 1. Solo el dueño de la clave conoce P, S y el código de Goppa.

  1. Deshaz la permutación: y = c\,P^{-1} = (m S)\,G + e P^{-1}. El error cambia de sitio pero sigue pesando 2. 0001011010000111
3.2 El algoritmo de Patterson, paso a paso

Hay que averiguar dónde está e P^{-1}. Se calcula el síndrome de y, y con él un polinomio localizador de errores \sigma cuyas raíces (en el soporte) son las posiciones del error.

  1. Síndrome S(z) = \sum_{y_j = 1} \frac{1}{z - \alpha_j} \bmod g S(z) = \alpha^{8}\,z + \alpha^{12}
  2. Inverso T(z) = S(z)^{-1} \bmod g T(z) = \alpha^{8}\,z + \alpha^{7}
  3. T(z) + z \alpha^{2}\,z + \alpha^{7}
  4. Se escribe T + z = Q_0^2 + z\,Q_1^2 y se toma la raíz cuadrada R = Q_0 + \sqrt{z}\,Q_1 \bmod g (en característica 2 siempre existe): Q_0 = \alpha^{11},\quad Q_1 = \alpha,\quad \sqrt z = \alpha^{3}\,z + \alpha^{3}
    R(z) = \alpha^{4}\,z + \alpha^{13}
  5. Euclides extendido sobre (g, R), hasta un resto de grado ≤ ⌊t/2⌋ = 1: aparecen a y b con a \equiv b R \pmod g.
    cocienteresto ruv
    z^2 + α^9·z + 110
    α^4·z + α^1301
  6. a = \alpha^{4}\,z + \alpha^{13},\quad b = 1
  7. El localizador \sigma(z) = a(z)^2 + z\,b(z)^2 \sigma(z) = \alpha^{8}\,z^{2} + z + \alpha^{11}
  8. Raíces de \sigma entre los elementos del soporte → posiciones del error: \sigma(\alpha^{5}) = 0 → posición 6\sigma(\alpha^{13}) = 0 → posición 14
  1. Se quita el error: y + e P^{-1} = (m S)\,G, una palabra del código de Goppa. 0001010010000101
  2. Como G es la identidad en el conjunto de información J, las coordenadas de la palabra en J son m S (8 bits): 00010001
  3. Y se multiplica por la inversa de S: m = (m S)\,S^{-1}. 01001000
Mensaje descifrado: Hola ✓ coincide con el original

4 Sé el atacante

Eres el atacante: solo tienes la clave pública G′ y el texto cifrado del bloque 1. El ataque de Prange elige 8 columnas al azar (un «conjunto de información»); si el error no cae en ninguna de ellas, con esas 8 columnas puedes despejar el mensaje con álgebra lineal y comprobar que lo que sobra pesa 2. Cada intento acierta con probabilidad baja; se repite hasta que sale.

Intentos esperados con estos parámetros: ≈ 15.

De juguete a real: la tabla de extrapolación

Costes estimados de los ataques de Prange y Stern y tamaños de clave, desde el juguete hasta los parámetros reales
Parámetrosn, t, kPrange: iteraciones (log₂)Prange: operaciones (log₂)Prange: tiempoStern: operaciones (log₂)Stern: tiempoClave pública, forma de 1978 (G′, k × n bits)Clave pública de Classic McEliece (T)Texto cifrado (Classic)
De juguete (el de arriba)16, 2, 82,111,7menos de 1 ms12,6 (p = 1, ℓ = 5)menos de 1 ms16 B——
McEliece 19781024, 50, 52453,681,110⁷ años63,5 (p = 3, ℓ = 27)42,4 años65,5 KiB——
mceliece3488643488, 64, 2720142,8173,610³⁵ años147,4 (p = 3, ℓ = 36)10²⁷ años1,13 MiB255 KiB96 B
mceliece4608964608, 96, 3360184,9217,410⁴⁸ años189,2 (p = 3, ℓ = 37)10³⁹ años1,85 MiB511,9 KiB156 B
mceliece66881286688, 128, 5024262,4296,310⁷² años264,8 (p = 5, ℓ = 57)10⁶² años4,01 MiB1020,5 KiB208 B
mceliece69601196960, 119, 5413263,4297,210⁷² años265,3 (p = 6, ℓ = 66)10⁶² años4,49 MiB1022,8 KiB194 B
mceliece81921288192, 128, 6528300,1334,410⁸³ años300,4 (p = 8, ℓ = 85)10⁷³ años6,38 MiB1,29 MiB208 B
  • Prange es el ataque genérico básico, no el mejor. Stern (1989) y sus sucesores lo mejoran mucho; por eso hay una columna con Stern, en un modelo sencillo y sin sus mejoras posteriores. Los parámetros reales se eligen frente a ataques todavía mejores y con modelos de coste más finos (memoria incluida), así que estas cifras son órdenes de magnitud y no el nivel de seguridad que declara Classic McEliece.
  • La lección: con parámetros de juguete, el ataque acaba al instante (pruébalo arriba). Pasar a n = 3488 o más convierte el mismo ataque en un cálculo fuera de alcance. La seguridad de McEliece es esa distancia, no un secreto del algoritmo.
  • El precio es el tamaño: la clave pública de Classic McEliece ocupa de cientos de kilobytes a más de un megabyte (en 1978 bastaban unos 65 KiB con n = 1024), pero el texto cifrado es muy corto.
  • «Clave pública de Classic McEliece» es la matriz T de la versión de Niederreiter con clave sistemática: no es exactamente la G′ de esta demo (columna anterior), que se da para comparar.

¿Y los ataques de 2025-2026?

En 2025 y 2026 se han publicado trabajos nuevos contra los códigos de Goppa binarios de Classic McEliece. Lo demostrado es un distinguidor: permite reconocer que una clave pública no es una matriz aleatoria, pero no descifra nada. Las recuperaciones de clave son heurísticas, con estimaciones de coste por debajo del nivel de seguridad declarado en el modelo de operaciones de bit (que no cobra la memoria): se ha estrechado el margen, pero no hay ningún ataque práctico. El BSI alemán desaconseja Classic McEliece para desarrollos nuevos desde el 1 de octubre de 2026.

Esta demo es el McEliece original de 1978, no Classic McEliece. Léelo con calma en el artículo, con las fuentes.

Abrir la herramienta a pantalla completa

Por qué el ordenador cuántico no le hace lo que a RSA

RSA se apoya en la factorización, y el algoritmo de Shor factoriza en tiempo razonable en un ordenador cuántico suficientemente grande (lo cuenta ¿Puede un ordenador cuántico romper RSA hoy?). McEliece no se apoya en la factorización ni en el logaritmo discreto, así que Shor no se aplica a él. No se conoce un algoritmo cuántico que decodifique un código lineal cualquiera con un salto comparable.

Lo que sí se aplica es el algoritmo de búsqueda de Grover, que reduce una búsqueda sin estructura de NN pasos a unos N\sqrt N. Bernstein mostró en 2010 («Grover vs. McEliece») que se puede usar dentro de la decodificación por conjuntos de información, el mejor ataque genérico: su coste pasa a ser aproximadamente la raíz cuadrada del coste clásico, es decir, el exponente se divide por dos (de c(1+o(1))n/log⁡2nc^{(1+o(1))n/\log_2 n} a c(1/2+o(1))n/log⁡2nc^{(1/2+o(1))n/\log_2 n} operaciones, con cc una constante que depende de la tasa del código). Es un tipo de ventaja distinta: no convierte el problema en fácil, solo lo acelera, y se compensa con parámetros mayores (asintóticamente, duplicar la longitud nn, lo que multiplica por cuatro el tamaño de la clave).

La frase justa es esta: un ordenador cuántico no le hace a McEliece lo que a RSA; lo que le preocupa hoy a los criptógrafos son los ataques clásicos a la estructura del código, y no los cuánticos.

El precio: claves enormes

La clave pública es una matriz grande. Según la especificación de Classic McEliece del 23 de octubre de 2022, la clave pública ocupa mt⌈k/8⌉mt\lceil k/8\rceil bytes (con k=n−mtk=n-mt) y el texto cifrado ⌈mt/8⌉\lceil mt/8\rceil bytes. Con los conjuntos de parámetros que la especificación define:

ConjuntoClave públicaTexto cifrado
mceliece348864261 120 bytes96 bytes
mceliece460896524 160 bytes156 bytes
mceliece66881281 044 992 bytes208 bytes
mceliece69601191 047 319 bytes194 bytes
mceliece81921281 357 824 bytes208 bytes

(Calculadas con la fórmula de la especificación; el script está en el repositorio de la web.) Es decir, claves de entre un cuarto de megabyte y 1,4 MB, pero cifrados cortos. Classic McEliece es, en rigor, la variante de McEliece con síndromes (la de Niederreiter) empaquetada como mecanismo de encapsulación de claves; la idea es la misma.

Historia: 1978-2026

Por qué resistió. McEliece lo propuso en 1978, en un informe del Jet Propulsion Laboratory, con un código de Goppa binario de longitud 1024, dimensión 524 y 50 errores. Desde entonces, los ataques que recuperan la clave aprovechando la estructura del código han tenido éxito contra casi todas las alternativas:

  • Reed-Solomon generalizados: Sidelnikov y Shestakov mostraron en 1992 cómo recuperar la clave en un tiempo que crece como una potencia del tamaño.
  • Subcódigos de Reed-Solomon: Wieschebrink (2010) los atacó.
  • Reed-Muller: Minder y Shokrollahi (2007) recuperaron la clave en tiempo subexponencial, y Chizhov y Borodin (2013) lo hicieron mucho más rápido: en tiempo polinómico cuando mcd⁡(r,m−1)\operatorname{mcd}(r,m-1) está acotado, para el código RM(r,m)\mathrm{RM}(r,m).
  • Goppa «salvajes» sobre extensiones cuadráticas: Couvreur, Otmani y Tillich (2014).
  • Variantes cuasicíclicas y cuasidiádicas (para acortar la clave): Faugère, Otmani, Perret y Tillich (2010) recuperaron la clave de la mayoría de los parámetros propuestos.

Los Goppa binarios del esquema original, no. Durante más de cuatro décadas no apareció contra ellos un ataque estructural mejor que la decodificación genérica. Eso no quiere decir que los parámetros de 1978 sigan valiendo: Bernstein, Lange y Peters (2008) los rompieron precisamente por decodificación genérica, y por eso hoy se usan códigos mucho más largos. Con matices que la historia exige: hay subclases débiles dentro de los Goppa binarios (polinomio generador binario, Loidreau-Sendrier 2001; tasa muy alta) y quedan fuera de este relato BIKE (códigos MDPC cuasicíclicos, sin estructura algebraica que recuperar) y HQC, que no esconde un código decodificable y por tanto no es McEliece en sentido estricto.

Classic McEliece. Es la propuesta de McEliece con Goppa binarios que se presentó al NIST (su especificación es del equipo de Classic McEliece). En marzo de 2025, el informe IR 8545 del NIST lo dejó fuera del proceso actual (se seleccionó HQC) y dijo que el progreso reciente en criptoanálisis «socava algo» el argumento de tratarlo como una opción especialmente conservadora. El motivo principal que da el informe es la duda sobre su adopción, no la seguridad. En junio de 2026, ISO publicó la enmienda ISO/IEC 18033-2:2006/Amd 2:2026 que lo incluye.

2025-2026: por qué ahora se estrecha el margen. Hasta entonces, lo más serio contra un Goppa binario era un distinguidor de 2011 (Faugère, Gauthier-Umaña, Otmani, Perret y Tillich) que solo valía para códigos de tasa muy alta (el régimen de las firmas CFS), no para los parámetros de Classic McEliece. Cambió con:

  • El distinguidor por sicigias de Hugues Randriambololona (EUROCRYPT 2025, mejor artículo, compartido con otro): es heurístico y subexponencial, el primero que baja de la barrera exponencial en el régimen de Classic McEliece, aunque para mceliece348864 estima unas 24012^{401} operaciones, «inalcanzable en la práctica» según el propio autor.
  • GIJS (agosto de 2026): Ghoshal, Ishai, Jain y Sun publican un distinguidor cuasipolinómico demostrado (tiempo nO(log⁡n)n^{O(\log n)} en un régimen asintótico concreto). Para los cinco conjuntos reales, sus autores estiman entre 21142^{114} y 21242^{124} operaciones de bit; lo llaman mejora «aunque aún no práctica».
  • Recuperación de clave heurística: el propio GIJS, y después Weis, Vedenev y Saarinen, dan estimaciones de recuperar la clave que dependen de conjeturas declaradas y probadas solo en tamaños de juguete. Van desde unos 2902^{90} hasta unos 21492^{149} operaciones de bit según el trabajo, la versión y el conjunto de parámetros. Todas quedan por debajo del nivel declarado (21432^{143}, 22072^{207} y 22722^{272} operaciones para las categorías 1, 3 y 5) en el modelo de operaciones de bit, que no cobra el acceso a memoria. Si se cobra como hace la guía de seguridad de Classic McEliece, Weis estima en el resumen de su versión de octubre entre 21172^{117} y 21282^{128}: las cifras suben, pero siguen por debajo del nivel declarado y de la decodificación genérica, aunque con menos diferencia.

Lo que no ha pasado: nadie ha recuperado una clave ni descifrado un mensaje con parámetros reales. Lo más grande que se ha resuelto son retos de juguete del TII (con m=8m=8 y nn alrededor de 220). El equipo de Classic McEliece contestó el 21 de agosto, antes de la versión de GIJS que añade la recuperación de clave (27 de agosto), que el ataque de GIJS es más lento que los ataques estándar para todos los conjuntos y que el algoritmo «solo detecta» si una cadena es una clave pública; no se encontraron declaraciones oficiales posteriores a esa fecha sobre los demás trabajos (la búsqueda llegó hasta el 5 de octubre). Varios trabajos de 2026 declaran haber usado modelos de IA, y el BSI avisa de que los trabajos recientes no tienen revisión por pares y de que falta comprobar el coste del acceso a memoria.

Las instituciones. El BSI alemán publicó el 1 de octubre de 2026 una nota fechada el 29 de septiembre: Classic McEliece no debería usarse en desarrollos nuevos, y recomienda FrodoKEM, ML-KEM o HQC (este cuando haya estándar). Dice a la vez que los trabajos recientes no permiten un ataque práctico con los parámetros de su guía TR-02102-1, mantiene el uso híbrido ya existente y revisará la guía a principios de 2027.

Una tesis

Resumiendo la historia: de todas las familias de códigos algebraicos propuestas para McEliece, solo los Goppa binarios genéricos de tasa moderada han resistido cuatro décadas; casi todas las demás cayeron. Con tres correcciones necesarias. Primera: dentro de los Goppa binarios hay subclases débiles (polinomio generador binario, tasa muy alta), y fuera de los códigos algebraicos sigue en pie BIKE. Segunda: «han resistido» significa que no había ataque estructural mejor que la decodificación genérica con los parámetros reales. Tercera: desde 2025 y 2026 eso ya no es cierto en el plano teórico, porque hay un distinguidor demostrado más barato que la decodificación genérica y recuperaciones de clave heurísticas que, según sus estimaciones en el modelo de operaciones de bit, también lo serían. Tienen todavía seguridad práctica, pero dejaron de ser una opción sin grietas.

Un ejemplo pequeño

Un ejemplo de juguete, con el código de Hamming [7,4][7,4], que corrige un error (t=1t=1). No es un código de Goppa real y se rompe a mano, pero muestra la mecánica. Las cuentas están verificadas con Python (mod 2).

Matriz generatriz del código secreto G=(I4∣A)G=(I_4\mid A) (su matriz de paridad es H=(AT∣I3)H=(A^{\mathsf T}\mid I_3), con columnas (1,1,0)(1,1,0), (1,0,1)(1,0,1), (0,1,1)(0,1,1), (1,1,1)(1,1,1), (1,0,0)(1,0,0), (0,1,0)(0,1,0), (0,0,1)(0,0,1)):

G=(1000110010010100100110001111)G=\begin{pmatrix}1&0&0&0&1&1&0\\0&1&0&0&1&0&1\\0&0&1&0&0&1&1\\0&0&0&1&1&1&1\end{pmatrix}

La clave secreta incluye una matriz invertible SS de 4×44\times4 y una permutación PP de las 7 columnas:

S=(1101011000111001),S=\begin{pmatrix}1&1&0&1\\0&1&1&0\\0&0&1&1\\1&0&0&1\end{pmatrix},

y PP manda la columna 1 a la posición 4, la 2 a la 1, la 3 a la 7, la 4 a la 3, la 5 a la 6, la 6 a la 2 y la 7 a la 5. La clave pública es G′=SGPG'=SGP:

G′=(1011010110001100100110011100)G'=\begin{pmatrix}1&0&1&1&0&1&0\\1&1&0&0&0&1&1\\0&0&1&0&0&1&1\\0&0&1&1&1&0&0\end{pmatrix}

Bob cifra m=(1,0,1,1)m=(1,0,1,1) con un error en la posición 5, e=(0,0,0,0,1,0,0)e=(0,0,0,0,1,0,0):

c=mG′+e=(1,0,1,0,0,0,1).c=mG'+e=(1,0,1,0,0,0,1).

Alicia deshace la permutación: cP−1=(0,1,1,1,0,0,0)cP^{-1}=(0,1,1,1,0,0,0), que es mSGmSG con el error movido de sitio. El síndrome es (0,0,1)(0,0,1), igual que la columna 7 de HH, así que el error está en la coordenada 7. Corrige y obtiene (0,1,1,1,0,0,1)(0,1,1,1,0,0,1). Sus cuatro primeras coordenadas son mS=(0,1,1,1)mS=(0,1,1,1), y al multiplicar por S−1S^{-1} aparece m=(1,0,1,1)m=(1,0,1,1).

¿Por qué esto es de juguete? Porque con solo 16 mensajes y 7 posiciones de error posibles, Eva prueba los 16×716\times7 casos y encuentra el único que cuadra. Con parámetros reales (nn de miles, tt de decenas o centenares) eso es imposible. El curso de códigos correctores explica la decodificación por síndrome que se usa aquí.

Las matemáticas de verdad

El código de Goppa

Sea F=F2mF=\mathbb F_{2^m}. Se escogen L=(α1,…,αn)L=(\alpha_1,\dots,\alpha_n), elementos distintos de FF (el soporte), y un polinomio g∈F[x]g\in F[x] de grado tt, mónico, irreducible y por tanto sin raíces en LL. El código de Goppa binario es

Γ(L,g)={c∈F2 n  :  ∑i=1ncix−αi≡0(modg(x))}.\Gamma(L,g)=\Bigl\{c\in\mathbb F_2^{\,n}\;:\;\sum_{i=1}^{n}\frac{c_i}{x-\alpha_i}\equiv 0 \pmod{g(x)}\Bigr\}.

Su matriz de control sobre FF es

H=(αj ig(αj))0≤i<t,  1≤j≤n.H=\Bigl(\frac{\alpha_j^{\,i}}{g(\alpha_j)}\Bigr)_{0\le i<t,\;1\le j\le n}.

Escribiendo cada entrada de FF como mm bits sale una matriz binaria de mtmt filas, de modo que la dimensión es k≥n−mtk\ge n-mt. Como gg es irreducible, no tiene factores repetidos (es libre de cuadrados), y para un Goppa binario eso basta: la distancia mínima es al menos 2t+12t+1 y el algoritmo de Patterson (1975) corrige hasta tt errores en tiempo razonable usando gg y LL.

El esquema

Con GG generatriz de Γ(L,g)\Gamma(L,g), SS invertible k×kk\times k y PP matriz de permutación n×nn\times n, la clave pública es G′=SGPG'=SGP y la secreta (L,g,S,P)(L,g,S,P). Para cifrar m∈F2km\in\mathbb F_2^k se elige ee de peso tt:

c=mG′+e.c=mG'+e.

Para descifrar:

cP−1=(mS)G+eP−1,cP^{-1}=(mS)G+eP^{-1},

y como eP−1eP^{-1} también tiene peso tt, Patterson devuelve la palabra (mS)G(mS)G; de ella se lee mSmS (si GG es sistemática, son sus kk primeras coordenadas) y se multiplica por S−1S^{-1}. (Classic McEliece usa la forma equivalente de Niederreiter: la clave pública es TT, con H=(Imt∣T)H=(I_{mt}\mid T), y el texto cifrado es el síndrome C=HeC=He de un vector ee de peso tt.)

Goppa dentro de Reed-Solomon, y por qué importa

Un código de Reed-Solomon generalizado (GRS) de dimensión rr sobre FF es el conjunto de vectores (v1f(α1),…,vnf(αn))(v_1f(\alpha_1),\dots,v_nf(\alpha_n)) con f∈F[x]f\in F[x] de grado menor que rr y vi≠0v_i\ne0. Todo código de Goppa binario Γ(L,g)\Gamma(L,g) es el subcódigo sobre el subcuerpo F2\mathbb F_2 de un GRS de dimensión n−tn-t: los vectores binarios de ese GRS (por eso se dice que es un código alternante). Cuando gg no tiene factores repetidos (y 2t<n2t<n), además Γ(L,g)=Γ(L,g2)\Gamma(L,g)=\Gamma(L,g^2), así que queda contenido en un GRS más pequeño, de dimensión n−2tn-2t. Es una propiedad conocida del código, no un defecto del esquema, pero tiene dos consecuencias.

  1. Por qué cayeron las variantes. Los GRS tienen una estructura muy rígida y Sidelnikov y Shestakov (1992) la usaron para recuperar la clave. Las variantes que conservaban o añadían estructura (subcódigos de GRS, Goppa sobre extensiones cuadráticas, versiones cuasicíclicas y cuasidiádicas) cayeron una tras otra. Que la causa común sea haber dejado demasiada estructura a la vista es la lectura que sugiere la historia, no un teorema. En los Goppa binarios de tasa moderada, pasar al subcuerpo F2\mathbb F_2 esconde bien esa estructura, o lo hacía.
  2. Por qué el distinguidor ataca justo ahí. La prueba del distinguidor de GIJS usa exactamente esa contención: un Goppa binario con gg libre de cuadrados está en un GRS de dimensión n−2tn-2t, y al componer con una curva oculta se obtiene un polinomio de una variable, de grado acotado, con n−1n-1 ceros de multiplicidad ss; por interpolación de Hermite ese polinomio es cero, y por eso un cierto núcleo se anula siempre en una columna reservada. Con una matriz uniforme, el test lo acepta con probabilidad como mucho 1−2−d1-2^{-d}, de modo que distingue. El régimen en que es cuasipolinómico (mm del orden de log⁡n\log n, tt del orden de n/log⁡nn/\log n) no es el de los parámetros reales, donde se usan d=8d=8 y s=7s=7 fijos tras acortar el código, con una estimación de 21142^{114} a 21242^{124} operaciones de bit.

La contención dice que el código es «casi» un GRS. Los esquemas con Goppa funcionan porque pasar a F2\mathbb F_2 esconde casi toda esa estructura. Los ataques de 2025 y 2026 miden cuánta queda.

Y ahora, ¿qué?

Si quieres ver los ingredientes, el curso de códigos correctores llega a Reed-Solomon y a la decodificación por síndrome. Para el lado cuántico, ¿Puede un ordenador cuántico romper RSA hoy? cuenta qué haría falta para romper RSA con Shor. Cuánto margen queda a McEliece se verá cuando salgan las revisiones por pares y la reevaluación del BSI, prevista para principios de 2027.

Fuentes

Preguntas frecuentes

¿Puede un ordenador cuántico romper el cifrado de McEliece como rompería RSA?

No con el mismo método. El algoritmo de Shor factoriza y calcula logaritmos discretos, que es lo que sostiene a RSA y a Diffie-Hellman, y McEliece no se apoya en ninguno de los dos: se apoya en la dificultad de decodificar un código lineal sin conocer su estructura. Contra ese problema lo que se conoce es usar la búsqueda de Grover dentro de los ataques genéricos, que según Bernstein (2010) reduce su coste aproximadamente a la raíz cuadrada: una aceleración de otra clase, que se compensa con parámetros mayores. Eso no quiere decir que McEliece sea invulnerable: hoy el motivo de preocupación son los ataques clásicos a la estructura de los códigos de Goppa, no los cuánticos.

¿Se ha roto Classic McEliece en 2026?

No. Hasta donde sabemos, nadie ha recuperado una clave ni descifrado un mensaje con los parámetros reales. Lo que hay es un distinguidor cuasipolinómico demostrado (reconoce que una clave pública no es una matriz aleatoria, pero no descifra), varias recuperaciones de clave heurísticas con estimaciones por debajo del nivel declarado en el modelo de operaciones de bit, y retos de juguete resueltos. Se ha estrechado el margen de seguridad; no hay ningún ataque práctico conocido. El BSI desaconseja usarlo en desarrollos nuevos y mantiene el uso híbrido existente.

¿Por qué las claves de McEliece son tan grandes?

Porque la clave pública es una matriz entera de ceros y unos que describe el código disfrazado. En la especificación oficial de Classic McEliece (23 de octubre de 2022) ocupa 261 120 bytes en el conjunto más pequeño, mceliece348864, y 1 357 824 bytes en mceliece8192128. A cambio, el texto cifrado es muy corto: entre 96 y 208 bytes en esos conjuntos.

¿Qué es un distinguidor y por qué no es lo mismo que romper el cifrado?

Un distinguidor es un procedimiento que, dada una matriz, decide si es la clave pública de McEliece o una matriz elegida al azar. Si lo hace mejor de lo previsto, se rompe una hipótesis de las demostraciones de seguridad (que la clave parece aleatoria), pero no se obtiene ni la clave secreta ni el mensaje. El equipo de Classic McEliece discute incluso que deba llamarse «ataque»; los autores del distinguidor de 2026 reconocen que su versión es una mejora «though not yet practical».

¿Por qué McEliece usa códigos de Goppa y no otros códigos?

Porque son los que han aguantado. Casi todas las familias de códigos propuestas como alternativa, entre ellas Reed-Solomon generalizados, Reed-Muller, Goppa «salvajes» sobre extensiones cuadráticas y las variantes cuasicíclicas y cuasidiádicas, han sido atacadas con éxito. Los Goppa binarios del esquema original (con parámetros mayores que los de 1978) son la excepción histórica entre las familias algebraicas, aunque desde 2025 ya no están libres de grietas teóricas.

¿Qué tiene que ver McEliece con el código QR?

Los dos usan códigos correctores, con papeles opuestos. El QR añade redundancia para que el lector repare los bytes dañados, y cualquiera puede hacerlo. McEliece añade errores a propósito y esconde cuál es el código que los repara: solo quien lo conoce puede quitarlos.

Publicado el

Para saber más

  1. ¿Por qué funciona RSA? Explicado paso a paso

    Multiplicar dos primos es fácil y deshacerlo no. Con un ejemplo completo y la demostración del teorema de Euler, por qué RSA cifra y descifra sin compartir claves.

    7 min de lectura
  2. ¿Puede un ordenador cuántico romper RSA hoy?

    Qué haría falta para romper RSA-2048 con el algoritmo de Shor, según las estimaciones publicadas más recientes. Página viva: se actualiza con cada estimación nueva.

    3 min de lectura