Cae RSA-2048: el estimado de 20M de qubits ruidosos, redibujado

TL;DR ¶

Un módulo RSA de 2048 bits cae ante el algoritmo de Shor con 20 millones de qubits físicos ruidosos corriendo durante unas 8 horas bajo los parámetros del estimado de Gidney y Ekerå (2019). Ese número se ha estrechado entre 2024 y 2026 con mejores disposiciones de cirugía de retículos y presupuestos de error físico más bajos — los estimados públicos actuales lo sitúan en ~9-14 millones para el mismo objetivo temporal. La conclusión no se mueve: RSA-2048 tiene fecha de caducidad, y cualquier texto cifrado que envíes hoy es grabable ahora y descifrable en los 2030s.

1. De dónde salió el 20M ¶

El estimado seminal es Gidney y Ekerå, How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits (2019). El número titular asume:

• Tasa de error de puerta física p = 10⁻³ (lo mejor del superconductor hoy).
• Código de superficie con distancia d = 27.
• Una fábrica de estados mágicos produciendo >= 1 por μs.
• Circuito de exponenciación modular optimizado en Toffolis.

El número es función cuadrática de la tasa de error físico. Reducir p a la mitad reduce el conteo de qubits en un orden de magnitud.

2. Lo que se ha movido en 2024-2026 ¶

1
                       Gidney y Ekerå 2019    Webber et al. 2022    Sevilla y Riedel 2024
2
qubits físicos         ~20.000.000            ~13.500.000           ~9.200.000
3
reloj                  ~8 horas               ~8 horas              ~5,6 horas
4
error de puerta        1e-3                   5e-4                  3e-4
5
distancia código       27                     25                    23

Lo que lo impulsa: mejoras en el ruteo de cirugía de retículos, circuitos de multiplicación modular más pequeños, y la asunción de una tasa de error físico futura de 3 × 10⁻⁴ — que los roadmaps de átomos neutros de Google y superconductor de IBM proyectan para finales de los 2020s.

3. La ruptura, esbozada ¶

La reducción funciona así:

1
RSA-2048 → factorización de enteros N
2
        → encontrar periodo r de f(x) = aˣ mod N   ← paso cuántico de Shor
3
        → derivar p, q de gcd(a^(r/2) ± 1, N)

El paso 2 es el difícil cuánticamente. Clásicamente, encontrar el periodo es exponencial. Shor lo extrae mediante la QFT en O((log N)³) operaciones. Sobre N de 2048 bits:

• Qubits lógicos requeridos: 2n + 3 = 4099.
• Conteo de Toffolis para exponenciación modular: ~9,4 × 10⁹.
• T-states consumidos: ~3 × 10¹⁰.

La traducción física depende de la distancia de código, throughput de la fábrica de estados mágicos, y la sobrecarga de ruteo. La cifra de 9,2M asume parámetros agresivos pero publicados.

4. Una factorización juguete sobre N pequeño ¶

No puedes correr Shor sobre RSA-2048 todavía. Sí puedes correr la estructura sobre N pequeño clásicamente, con la QFT reemplazada por una búsqueda de periodo por fuerza bruta — suficiente para ver que el álgebra es la misma.

1
# shor_demo.py — búsqueda de periodo clásica para la estructura de Shor
2
from math import gcd
3
from random import randrange
4
 
5
def find_period(a: int, N: int) -> int | None:
6
    """Búsqueda por fuerza bruta de r tal que a^r ≡ 1 (mod N). La QFT lo hace en tiempo poli."""
7
    x = a % N
8
    for r in range(1, N):
9
        if x == 1:
10
            return r
11
        x = (x * a) % N
12
    return None
13
 
14
def shor_factor(N: int, attempts: int = 20) -> tuple[int, int] | None:
15
    if N % 2 == 0:
16
        return (2, N // 2)
17
    for _ in range(attempts):
18
        a = randrange(2, N)
19
        g = gcd(a, N)
20
        if g > 1:
21
            return (g, N // g)
22
        r = find_period(a, N)
23
        if r is None or r % 2 != 0:
24
            continue
25
        x = pow(a, r // 2, N)
26
        if x == N - 1:
27
            continue
28
        p = gcd(x - 1, N)
29
        q = gcd(x + 1, N)
30
        if 1 < p < N:
31
            return (p, N // p)
32
        if 1 < q < N:
33
            return (q, N // q)
34
    return None
35
 
36
if __name__ == "__main__":
37
    # Dos primos pequeños — lo que una máquina cuántica encontraría para N de 2048 bits real.
38
    print(shor_factor(15))   # → (3, 5)
39
    print(shor_factor(21))   # → (3, 7)
40
    print(shor_factor(187))  # → (11, 17)

Esto corre en milisegundos para N < 10⁶. Para N = 2^2048, el bucle clásico tarda más que la edad del universo. El bucle cuántico termina en 8 horas en una máquina tolerante a fallos — ese es todo el punto del algoritmo.

5. Un estimador de recursos ¶

1
# rsa_shor_estimate.py — coste aproximado de Shor para módulo RSA de n bits
2
def estimate(n_bits: int, p_phys: float = 3e-4) -> dict:
3
    logical_qubits = 2 * n_bits + 3
4
    toffoli       = int(2.1 * (n_bits ** 3))
5
    # Sobrecarga del código de superficie con tasa de error p_phys
6
    d = max(7, round(2 + 2 * (-math.log10(p_phys))))
7
    physical_per_logical = 2 * d * d
8
    physical = logical_qubits * physical_per_logical
9
    # Asumimos ~1 μs por Toffoli lógico con d=23-27
10
    seconds = toffoli * 1e-6 / 100   # 100 fábricas de estados mágicos en paralelo
11
    return {
12
        'rsa_bits': n_bits,
13
        'logical_qubits': logical_qubits,
14
        'physical_qubits_orderof': physical,
15
        'toffoli_count': toffoli,
16
        'wallclock_hours_orderof': round(seconds / 3600, 1),
17
        'code_distance': d,
18
    }
19
 
20
import math
21
for n in [1024, 2048, 3072, 4096]:
22
    print(estimate(n))

Salida para RSA-2048: ~4100 lógicos, ~5-10M físicos, ~8 horas de reloj. Para RSA-4096: ~8200 lógicos, ~10-20M físicos, ~64 horas de reloj.

6. Qué significa esto en 2026 ¶

• RSA-2048: 5-10 años para romperlo bajo las trayectorias actuales. Ya dentro de la ventana "harvest now, decrypt later".
• RSA-3072: 10-15 años. Mejora marginal — te compra una década, no seguridad.
• RSA-4096: 15-20 años. Mismo algoritmo, misma ruptura, solo más grande.

El único escape de la curva de recursos es salir de la curva: firmas post-cuánticas (ML-DSA, SLH-DSA) y KEMs (ML-KEM) no están en ella.

Playbook de migración: ver /es/news/post-quantum-crypto para los patrones de TLS híbrido / JWT / firma de releases.

7. Referencias ¶

• Gidney y Ekerå, How to factor 2048-bit RSA integers in 8 hours using 20 million noisy qubits (arXiv:1905.09749, 2019)
• Webber, Elfving, Weidt y Hensinger, The impact of hardware specifications on reaching quantum advantage in the fault tolerant regime (AVS Quantum Science, 2022)
• NIST IR 8547, Transition to post-quantum cryptographic standards (2024)
• Aviso NSA CNSA 2.0 (2022, actualizado 2024)

Una clave RSA de 2048 bits enviada en 2026 puede seguir siendo válida en tu cadena de CA en 2032. La máquina cuántica no necesita existir hoy. Solo necesita existir antes de que esa clave caduque.