Criptografía Post-Cuántica

Introducción

KodeChain es la primera blockchain de producción que implementa criptografía post-cuántica desde su diseño inicial, protegiendo contra ataques de computadoras cuánticas presentes y futuras.

La Amenaza Cuántica

Algoritmos Vulnerables

Algoritmos Clásicos (VULNERABLES a Quantum)
├── RSA
│   └── Roto por Algoritmo de Shor
├── ECDSA (Elliptic Curve)
│   └── Roto por Algoritmo de Shor
├── Diffie-Hellman
│   └── Roto por Algoritmo de Shor
└── DSA
    └── Roto por Algoritmo de Shor

Escala Temporal

2025: Computadoras cuánticas con ~100 qubits lógicos
      └── Amenaza teórica

2030: Computadoras cuánticas con ~1,000 qubits lógicos
      └── Amenaza real para RSA-2048

2035: Computadoras cuánticas con ~10,000 qubits lógicos
      └── Romper ECDSA-256 en horas

2040: Computadoras cuánticas universales
      └── Todos los algoritmos clásicos comprometidos

ML-DSA-65 (Dilithium3)

KodeChain implementa ML-DSA-65, el algoritmo de firma digital resistente a quantum estandarizado por NIST.

Especificaciones

Nombre Completo:    Module-Lattice-Based Digital Signature Algorithm
Nivel de Seguridad: NIST Level 3
Implementación:     Cloudflare CIRCL (Go)
Uso en KodeChain:   Todas las firmas (bloques, transacciones, mensajes)

Parámetros

Parámetro	Valor
Seguridad Clásica	~192 bits
Seguridad Cuántica	~96 bits
Tamaño Clave Pública	1,952 bytes
Tamaño Clave Privada	4,016 bytes
Tamaño Firma	3,293 bytes
Qubits para Romper	Millones de qubits lógicos

Comparación con Algoritmos Clásicos

Algoritmo	Tamaño Clave Pública	Tamaño Firma	Seguridad Cuántica
ML-DSA-65	1,952 bytes	3,293 bytes	~96 bits
RSA-3072	384 bytes	384 bytes	0 bits ❌
ECDSA-256	32 bytes	64 bytes	0 bits ❌
Ed25519	32 bytes	64 bytes	0 bits ❌

Conclusión: ML-DSA-65 es más grande pero SEGURO contra quantum.

Implementación en KodeChain

Estructura del Signer

type QuantumSigner struct {
    privateKey dilithium.PrivateKey  // 4,016 bytes
    publicKey  dilithium.PublicKey   // 1,952 bytes
    address    string                 // Derivado de pubkey
}

Generación de Claves

func GenerateQuantumKeys() (*QuantumSigner, error) {
    // Generar par de claves Dilithium3
    publicKey, privateKey, err := dilithium.GenerateKey(nil)
    if err != nil {
        return nil, err
    }

    // Derivar address desde public key
    hash := sha256.Sum256(publicKey)
    address := "0x" + hex.EncodeToString(hash[:20])

    return &QuantumSigner{
        privateKey: privateKey,
        publicKey:  publicKey,
        address:    address,
    }, nil
}

Firma de Datos

func (qs *QuantumSigner) Sign(data []byte) ([]byte, error) {
    // ML-DSA-65 signature
    signature := dilithium.Sign(qs.privateKey, data)
    return signature, nil
}

Resultado: Firma de 3,293 bytes resistente a quantum.

Verificación de Firma

func (qs *QuantumSigner) Verify(data, signature []byte) bool {
    // Verificar con ML-DSA-65
    return dilithium.Verify(qs.publicKey, data, signature)
}

Uso en Transacciones

// 1. Crear transacción
tx := &Transaction{
    From:   "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
    To:     "0x1234567890123456789012345678901234567890",
    Amount: "1000000000000000000",
    Nonce:  0,
}

// 2. Calcular hash
txHash := tx.CalculateHash()

// 3. Firmar con ML-DSA-65
signer, _ := NewQuantumSigner()
signature, _ := signer.Sign([]byte(txHash))

// 4. Adjuntar firma (3,293 bytes)
tx.Signature = hex.EncodeToString(signature)

Uso en Bloques

// 1. Crear bloque
block := &Block{
    Index:        15432,
    Timestamp:    time.Now().Format(time.RFC3339),
    Transactions: txs,
    PreviousHash: "0xabc123...",
    Validator:    "0x742d35...",
}

// 2. Calcular hash del bloque
block.Hash = block.CalculateHash()

// 3. Firmar con ML-DSA-65
validatorSigner, _ := LoadValidatorKeys()
signature, _ := validatorSigner.Sign([]byte(block.Hash))

// 4. Adjuntar firma
block.Signature = hex.EncodeToString(signature)

Uso en Mensajes P2P

// 1. Crear mensaje de anuncio
message := map[string]interface{}{
    "type": "announcement",
    "data": enodeData,
    "timestamp": time.Now().Unix(),
}

// 2. Serializar
messageBytes, _ := json.Marshal(message)

// 3. Firmar con ML-DSA-65
signature, _ := nodeSigner.Sign(messageBytes)

// 4. Añadir firma al mensaje
message["signature"] = hex.EncodeToString(signature)

// 5. Broadcast a la red
p2p.Broadcast(message)

Ventajas de ML-DSA-65

1. Seguridad a Largo Plazo

• Resistente a algoritmos cuánticos conocidos
• Basado en problemas matemáticos difíciles (lattices)
• Estandarizado por NIST (2024)

2. Performance Aceptable

• Generación de claves: ~1ms
• Firma: ~2ms
• Verificación: ~1ms

Comparación con ECDSA:

                ECDSA    ML-DSA-65
Keygen:         0.5ms    1ms
Sign:           0.5ms    2ms
Verify:         1ms      1ms

Diferencia:     ~2x más lento (aceptable)

3. Implementación Probada

• Cloudflare CIRCL (producción)
• Auditoría de seguridad
• Integración con Go

4. Future-Proof

• Protección contra quantum presente
• Protección contra quantum futuro
• Migración no requerida

Tamaño de Datos

Impacto en Blockchain

Transacción Tradicional (ECDSA):
├── From:      20 bytes
├── To:        20 bytes
├── Amount:    32 bytes
├── Nonce:     8 bytes
├── Signature: 64 bytes
└── TOTAL:     144 bytes

Transacción KodeChain (ML-DSA-65):
├── From:      20 bytes
├── To:        20 bytes
├── Amount:    32 bytes
├── Nonce:     8 bytes
├── Signature: 3,293 bytes
└── TOTAL:     3,373 bytes

Overhead: ~23x en tamaño de firma

Mitigaciones

1. Compresión: Signatures se pueden comprimir
2. Batch Verification: Verificar múltiples firmas en batch
3. Pruning: Firmas antiguas se pueden podar
4. State Channels: Transacciones off-chain

Resultado: El overhead es aceptable dado el beneficio de seguridad.

Otros Algoritmos Post-Cuánticos

NIST PQC Standards

Algoritmo	Tipo	Nivel	Estado en KodeChain
ML-DSA (Dilithium)	Firma	3	✅ Implementado
ML-KEM (Kyber)	KEM	3	📅 Roadmap
SLH-DSA (SPHINCS+)	Firma	3	📅 Roadmap
FN-DSA (Falcon)	Firma	3	❌ No planeado

Roadmap de Implementación

Fase 1 (Actual):

• ✅ ML-DSA-65 para todas las firmas

Fase 2 (Q2 2025):

• 📅 ML-KEM para key exchange
• 📅 Hybrid schemes (ML-DSA + ECDSA)

Fase 3 (Q4 2025):

• 📅 SLH-DSA como backup
• 📅 Quantum key distribution (QKD) support

Migración desde Blockchain Clásica

Para usuarios que quieran migrar desde blockchains con ECDSA:

1. Generar Nuevas Claves

cd handlers
make generate

Esto genera claves ML-DSA-65.

2. Transferir Fondos

# Desde wallet antigua (ECDSA)
transfer_to_kodechain(
    from: "0xOldAddress",
    to: "0xNewKodeChainAddress",
    amount: balance
)

3. Actualizar Aplicaciones

Actualizar SDKs para usar ML-DSA-65:

// Antes (ECDSA)
signer, _ := crypto.GenerateKey()

// Ahora (ML-DSA-65)
signer, _ := security.NewQuantumSigner()

Best Practices

1. Generación de Claves

// ✅ BIEN: Usar crypto/rand
publicKey, privateKey, _ := dilithium.GenerateKey(rand.Reader)

// ❌ MAL: Usar seed predecible
publicKey, privateKey, _ := dilithium.GenerateKey(nil)

2. Almacenamiento de Claves

// ✅ BIEN: Encriptar keystore
keystore := EncryptKeystore(privateKey, password)
SaveToFile("keystore.json", keystore)

// ❌ MAL: Almacenar en texto plano
SaveToFile("private.key", privateKey)

3. Gestión de Firmas

// ✅ BIEN: Verificar antes de procesar
if !VerifySignature(tx) {
    return errors.New("invalid signature")
}
ProcessTransaction(tx)

// ❌ MAL: Confiar sin verificar
ProcessTransaction(tx)

Próximos Pasos

1. ML-DSA-65 Explicado - Detalles técnicos
2. Gestión de Claves - Manejo seguro
3. Best Practices - Guía de seguridad

---

KodeChain: Seguridad quantum-resistant desde el día 1 🛡️