Post-Quantum Cryptography (PQC) es la criptografía diseñada para ser resistente a ataques de computadoras cuánticas, protegiendo sistemas contra la amenaza futura de la computación cuántica.

¿Qué es Post-Quantum Cryptography?

La criptografía post-cuántica incluye algoritmos criptográficos que se cree que son seguros contra ataques tanto de computadoras clásicas como cuánticas.

Amenaza Cuántica

Algoritmo de Shor

  • Factorización: Rompe RSA y ECC
  • Discrete Logarithm: Rompe Diffie-Hellman
  • Tiempo: Exponencial a polinomial
  • Impacto: Rompe criptografía asimétrica actual

Algoritmo de Grover

  • Búsqueda: Acelera búsqueda en base de datos
  • Hash Functions: Reduce seguridad a la mitad
  • Symmetric: Afecta cifrado simétrico
  • Impacto: Requiere claves más largas

Tiempo de Transición

  • Y2Q (Years to Quantum): Tiempo estimado
  • Harvest Now, Decrypt Later: Ataques de almacenamiento
  • Migration Period: Período de migración
  • Legacy Systems: Sistemas heredados

Familias de Algoritmos PQC

Lattice-Based (Basados en Retículos)

  • NTRU: Algoritmo de cifrado
  • Learning With Errors (LWE): Problema matemático
  • Ring-LWE: Variante de LWE
  • Aplicaciones: Cifrado, firmas, intercambio de claves

Code-Based (Basados en Códigos)

  • McEliece: Sistema de cifrado
  • Niederreiter: Sistema de cifrado
  • Classic McEliece: Versión estandarizada
  • Aplicaciones: Cifrado, intercambio de claves

Hash-Based (Basados en Hash)

  • XMSS: Firma digital
  • SPHINCS+: Firma digital
  • LMS: Firma digital
  • Aplicaciones: Firmas digitales

Isogeny-Based (Basados en Isogenias)

  • SIKE: Intercambio de claves
  • SIDH: Intercambio de claves
  • CSIDH: Intercambio de claves
  • Aplicaciones: Intercambio de claves

Multivariate (Multivariados)

  • Rainbow: Firma digital
  • GeMSS: Firma digital
  • LUOV: Firma digital
  • Aplicaciones: Firmas digitales

Algoritmos NIST Estándar

NIST Round 4 (2024)

  • CRYSTALS-Kyber: Cifrado KEM
  • CRYSTALS-Dilithium: Firma digital
  • FALCON: Firma digital
  • SPHINCS+: Firma digital

Algoritmos Alternativos

  • Classic McEliece: Cifrado KEM
  • BIKE: Cifrado KEM
  • HQC: Cifrado KEM
  • SIKE: Intercambio de claves (retirado)

Implementación Práctica

CRYSTALS-Kyber

 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

# Ejemplo conceptual de Kyber
import numpy as np
from cryptography.hazmat.primitives import hashes

class Kyber:
    def __init__(self, n=256, q=3329, k=2):
        self.n = n  # Grado del polinomio
        self.q = q  # Módulo
        self.k = k  # Dimensión del módulo
    
    def keygen(self):
        # Generar clave pública y privada
        s = self.sample_secret()
        A = self.sample_matrix()
        e = self.sample_error()
        
        t = (A @ s + e) % self.q
        pk = (A, t)
        sk = s
        
        return pk, sk
    
    def encrypt(self, pk, message):
        A, t = pk
        r = self.sample_secret()
        e1 = self.sample_error()
        e2 = self.sample_error()
        
        u = (A.T @ r + e1) % self.q
        v = (t @ r + e2 + message) % self.q
        
        return (u, v)
    
    def decrypt(self, sk, ciphertext):
        u, v = ciphertext
        message = (v - sk @ u) % self.q
        return message

CRYSTALS-Dilithium

 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

# Ejemplo conceptual de Dilithium
class Dilithium:
    def __init__(self, n=256, q=8380417, k=4, l=4):
        self.n = n
        self.q = q
        self.k = k
        self.l = l
    
    def keygen(self):
        # Generar clave pública y privada
        rho = self.sample_random()
        K = self.sample_random()
        
        A = self.expand_matrix(rho)
        s1 = self.sample_secret(self.l)
        s2 = self.sample_secret(self.k)
        
        t = (A @ s1 + s2) % self.q
        pk = (rho, t)
        sk = (rho, K, s1, s2, t)
        
        return pk, sk
    
    def sign(self, sk, message):
        rho, K, s1, s2, t = sk
        
        mu = self.hash_message(message)
        rho_prime = self.hash_keys(rho, t)
        kappa = 0
        
        while True:
            y = self.sample_gamma1()
            w = self.expand_matrix(rho_prime) @ y
            w1 = self.high_bits(w)
            c = self.hash_challenge(mu, w1)
            z = y + c * s1
            
            if self.check_norm(z) and self.check_norm(c * s2):
                h = self.make_hint(w - c * s2, w1)
                return (c, z, h)
            
            kappa += 1
            if kappa >= 100:
                return None
    
    def verify(self, pk, message, signature):
        rho, t = pk
        c, z, h = signature
        
        mu = self.hash_message(message)
        rho_prime = self.hash_keys(rho, t)
        w1 = self.expand_matrix(rho_prime) @ z - c * t
        w1 = self.use_hint(w1, h)
        c_prime = self.hash_challenge(mu, w1)
        
        return c == c_prime and self.check_norm(z)

Migración a PQC

Estrategia de Migración

  • Assessment: Evaluar sistemas actuales
  • Priorization: Priorizar sistemas críticos
  • Hybrid Approach: Enfoque híbrido
  • Testing: Pruebas exhaustivas

Enfoque Híbrido

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

# Ejemplo de enfoque híbrido
class HybridCrypto:
    def __init__(self):
        self.classical_crypto = RSACrypto()
        self.post_quantum_crypto = KyberCrypto()
    
    def encrypt(self, message):
        # Cifrar con ambos algoritmos
        classical_cipher = self.classical_crypto.encrypt(message)
        pq_cipher = self.post_quantum_crypto.encrypt(message)
        
        return {
            'classical': classical_cipher,
            'post_quantum': pq_cipher
        }
    
    def decrypt(self, ciphertext):
        # Intentar descifrar con ambos
        try:
            return self.classical_crypto.decrypt(ciphertext['classical'])
        except:
            return self.post_quantum_crypto.decrypt(ciphertext['post_quantum'])

Herramientas de Migración

  • Open Quantum Safe: Librerías PQC
  • NIST PQC Reference: Implementaciones de referencia
  • Migration Tools: Herramientas de migración
  • Testing Suites: Suites de prueba

Aplicaciones Específicas

Blockchain y Criptomonedas

  • Quantum-Resistant Wallets: Carteras resistentes
  • Post-Quantum Signatures: Firmas post-cuánticas
  • Quantum-Safe Transactions: Transacciones seguras
  • Migration Strategies: Estrategias de migración

Internet y Comunicaciones

  • TLS/SSL: Protocolos seguros
  • Email Security: Seguridad de correo
  • VPN: Redes privadas virtuales
  • DNS Security: Seguridad DNS

IoT y Dispositivos

  • Lightweight PQC: PQC ligero
  • Resource Constraints: Limitaciones de recursos
  • Power Consumption: Consumo de energía
  • Memory Usage: Uso de memoria

Gobierno y Defensa

  • National Security: Seguridad nacional
  • Classified Information: Información clasificada
  • Critical Infrastructure: Infraestructura crítica
  • Military Communications: Comunicaciones militares

Desafíos y Limitaciones

Rendimiento

  • Computational Overhead: Sobrecarga computacional
  • Memory Usage: Uso de memoria
  • Key Sizes: Tamaños de clave
  • Signature Sizes: Tamaños de firma

Implementación

  • Complexity: Complejidad de implementación
  • Testing: Pruebas exhaustivas
  • Interoperability: Interoperabilidad
  • Legacy Support: Soporte heredado

Estándares

  • NIST Standardization: Estandarización NIST
  • ISO Standards: Estándares ISO
  • IETF Standards: Estándares IETF
  • Industry Adoption: Adopción industrial

Herramientas y Librerías

Open Quantum Safe

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

# Ejemplo con liboqs
import oqs

# Generar claves Kyber
kem = oqs.KeyEncapsulation("Kyber512")
public_key, secret_key = kem.generate_keypair()

# Cifrar
ciphertext, shared_secret = kem.encap_secret(public_key)

# Descifrar
shared_secret_decrypted = kem.decap_secret(ciphertext, secret_key)

NIST PQC Reference

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

# Ejemplo con implementación de referencia
from pqcrypto import kyber, dilithium

# Kyber KEM
pk, sk = kyber.keypair()
ct, ss = kyber.encapsulate(pk)
ss_dec = kyber.decapsulate(ct, sk)

# Dilithium Signatures
pk, sk = dilithium.keypair()
sig = dilithium.sign(sk, message)
valid = dilithium.verify(pk, message, sig)

Roadmap y Cronograma

NIST Timeline

  • 2016: Inicio del proceso
  • 2022: Round 3 finalizado
  • 2024: Round 4 finalizado
  • 2025+: Implementación comercial

Adopción Industrial

  • 2025-2027: Implementación temprana
  • 2027-2030: Adopción generalizada
  • 2030+: Dominancia de PQC
  • Legacy: Sistemas heredados

Conceptos Relacionados

  • AES - Algoritmo que requiere claves más largas post-cuánticas
  • RSA - Algoritmo vulnerable a computación cuántica
  • ECC - Algoritmo vulnerable a computación cuántica
  • Funciones Hash - Algoritmos que requieren claves más largas
  • TLS/SSL - Protocolo que necesita migración PQC
  • PKI - Infraestructura que requiere PQC
  • HSM - Dispositivos que soportan PQC
  • CISO - Rol que supervisa migración PQC
  • Ciberseguridad General - Disciplina que incluye PQC
  • Brechas de seguridad - Incidentes que afectan PQC
  • Vectores de ataque - Ataques cuánticos
  • Incident Response - Proceso que incluye PQC
  • SIEM - Sistema que monitorea PQC
  • SOAR - Automatización que gestiona PQC
  • EDR - Herramienta que protege PQC
  • Firewall - Dispositivo que puede inspeccionar PQC
  • VPN - Conexión que utiliza PQC
  • Dashboards - Visualización de métricas PQC
  • Registros - Logs de operaciones PQC

Referencias