Firmas poscuánticas ML-DSA en Go 1.27: cómo funcionan crypto/mldsa y TLS 1.3 y por qué no se activan solasNota · digest del 22 de noviembre
Composición simbólica de criptografía poscuántica en Go 1.27 con un canal seguro TLS 1.3 y el algoritmo basado en retículos ML-DSA
Nota3 secciones≈ 5 min

Firmas poscuánticas ML-DSA en Go 1.27: cómo funcionan crypto/mldsa y TLS 1.3 y por qué no se activan solas

Una sola firma poscuántica del nivel más alto en Go 1.27 ocupa más de cuatro kilobytes: más de tres paquetes Ethernet estándar frente a la diminuta Ed25519. En agosto de 2026 el equipo de Go incorporó firmas poscuánticas ML-DSA directo en la biblioteca estándar, aunque tras recompilar tu servicio sin más no notarás ningún cambio en tu tráfico TLS.

Y es lo correcto. Si el compilador cambiara en silencio los handshakes al nuevo algoritmo, los clientes antiguos simplemente dejarían de conectarse.

Para qué sirven las firmas si ya existía intercambio de claves poscuántico

La criptografía poscuántica agrupa algoritmos resistentes al algoritmo de Shor en futuras computadoras cuánticas. El intercambio de claves ML-KEM ya estaba en Go desde antes, y la versión 1.27 le sumó MLKEM1024 para Config.CurvePreferences.

Pero ML-KEM y ML-DSA tapan brechas distintas. ML-KEM protege el tráfico interceptado contra un descifrado futuro. En cambio, las firmas ML-DSA bajo el estándar NIST FIPS 204 demuestran la autenticidad del servidor ahora mismo, impidiendo que un atacante falsifique el certificado X.509 (el pasaporte digital del servidor con su clave y firma de la autoridad certificadora) durante el handshake.

Qué llegó a la biblioteca estándar

La actualización abarca cuatro paquetes. El principal es crypto/mldsa con generación de claves, firma y verificación según FIPS 204. El paquete crypto/x509 aprendió a manejar claves y firmas ML-DSA en certificados. En crypto/tls para TLS 1.3 aparecieron tres valores de SignatureScheme (el código del algoritmo de firma del handshake): tls.MLDSA44, tls.MLDSA65 y tls.MLDSA87. Por último, crypto añadió la constante crypto.MLDSAMu para el modo External μ ML-DSA signing.

La clave privada *mldsa.PrivateKey implementa la interfaz estándar crypto.Signer:

package main

import (
    "crypto/mldsa"
    "fmt"
    "log"
)

func main() {
    // Generamos claves ML-DSA-65 (nivel base del NIST)
    sk, err := mldsa.GenerateKey(mldsa.MLDSA65())
    if err != nil {
        log.Fatal(err)
    }
    msg := []byte("post-quantum signature in Go 1.27")
    // El contexto (hasta 255 bytes) separa dominios de firma
    opts := &mldsa.Options{Context: "demo-tls-service"}

    sig, err := sk.Sign(nil, msg, opts)
    if err != nil {
        log.Fatal(err)
    }
    pub := sk.PublicKey().Bytes()
    pk, err := mldsa.NewPublicKey(mldsa.MLDSA65(), pub)
    if err != nil {
        log.Fatal(err)
    }
    if err := mldsa.Verify(pk, msg, sig, opts); err != nil {
        log.Fatal("invalid signature:", err)
    }
    fmt.Printf("OK: pub=%dB, sig=%dB\n", len(pub), len(sig))
}

La cadena Context en mldsa.Options debe coincidir al firmar y al verificar: así una firma de un protocolo no puede colarse en otro. Este es el costo en bytes de la resistencia cuántica:

AlgoritmoNivel de seguridadClave públicaFirmaSemilla de clave
Ed25519Clásico (~128 bits)32 B64 B32 B
MLDSA44NIST Category 2 (~128 bits)1,312 B2,420 B32 B
MLDSA65NIST Category 3 (~192 bits)1,952 B3,309 B32 B
MLDSA87NIST Category 5 (~256 bits)2,592 B4,627 B32 B

Los mensajes Certificate y CertificateVerify del handshake se vuelven bastante más pesados. La opción base recomendada es MLDSA65, mientras que MLDSA87 se adopta para cumplir con el perfil CNSA 2.0.

Por qué el servicio no cambia solo y cómo probarlo sin riesgos

Recompilar con Go 1.27 deja intactos tus certificados ECDSA o RSA actuales. Para activar ML-DSA necesitas TLS 1.3, nuevos certificados X.509 y soporte en ambos extremos. GetCertificate permite desplegar el esquema de forma gradual sin romper clientes antiguos:

func buildTLSConfig(pqCert, classicCert tls.Certificate) *tls.Config {
    return &tls.Config{
        // ML-DSA solo funciona sobre TLS 1.3
        MinVersion: tls.VersionTLS13,
        GetCertificate: func(
            hello *tls.ClientHelloInfo,
        ) (*tls.Certificate, error) {
            // Entregamos ML-DSA a quien lo anuncie en ClientHello
            if slices.Contains(hello.SignatureSchemes, tls.MLDSA65) {
                return &pqCert, nil
            }
            return &classicCert, nil
        },
    }
}

Los clientes recientes en Go 1.27 anunciarán tls.MLDSA65 y recibirán el certificado poscuántico, mientras los antiguos seguirán conectándose con la clave clásica.

Qué revisar antes de probar ML-DSA

  • La conexión está restringida a TLS 1.3 (MinVersion: tls.VersionTLS13).
  • Se emitieron certificados X.509 con claves ML-DSA.
  • El otro extremo (cliente o proxy) soporta MLDSA44, MLDSA65 o MLDSA87.
  • Los límites de red soportan paquetes de handshake más pesados.

Por ahora, ML-DSA en Go 1.27 resulta muy práctico en enlaces mTLS internos donde controlas ambos extremos, y para prepararte hacia NIST o CNSA 2.0 sin librerías de terceros. En sitios HTTPS públicos todavía es pronto para correr: los navegadores masivos y las autoridades certificadoras públicas aún no han migrado a estas cadenas de confianza.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 4