Saltar al contenido principal

Firmador Cuántico

En el corazón de la seguridad de KodeChain reside el QuantumSigner, una implementación pura de ML-DSA-65 que representa la culminación de años de investigación criptográfica post-cuántica. Este sistema, implementado en security/quantum_signer.go, no es solo una herramienta técnica; es la garantía de que KodeChain permanecerá segura incluso cuando las computadoras cuánticas se conviertan en realidad.

La Arquitectura del QuantumSigner​

QuantumSigner: La Estructura Fundamental​

type QuantumSigner struct {
    privateKey mldsa65.PrivateKey
    publicKey  mldsa65.PublicKey
    address    string
}

Esta estructura encapsula el trío esencial: clave privada para firmar, clave pública para verificar, y dirección para identificar. Cada instancia representa una identidad criptográfica completa y autónoma.

Inicialización Segura​

func NewQuantumSigner() (*QuantumSigner, error) {
    rng := newSimpleRand()
    publicKey, privateKey, err := mldsa65.GenerateKey(rng)
    if err != nil {
        return nil, err
    }

    pubKeyBytes, err := publicKey.MarshalBinary()
    if err != nil {
        return nil, err
    }

    address := GenerateQuantumHashHex(pubKeyBytes)

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

La creación de un nuevo firmador genera claves completamente nuevas usando el generador de números aleatorios simple, derivando la dirección de la clave pública mediante hash post-cuántico.

El Proceso de Firma​

Sign: La Transformación Digital​

func (qs *QuantumSigner) Sign(data []byte) ([]byte, error) {
    privBytes, err := qs.privateKey.MarshalBinary()
    if err != nil || len(privBytes) == 0 {
        return nil, errors.New("clave privada no inicializada")
    }

    signature := make([]byte, mldsa65.SignatureSize)
    mldsa65.SignTo(&qs.privateKey, data, nil, true, signature)

    return signature, nil
}

El proceso de firma toma los datos originales y los transforma en una firma de 3309 bytes que prueba matemáticamente la autenticidad y la integridad de los datos.

Verificación: La Validación Matemática​

func (qs *QuantumSigner) Verify(data []byte, signature []byte) bool {
    return mldsa65.Verify(&qs.publicKey, data, nil, signature)
}

La verificación confirma que la firma corresponde exactamente a los datos y fue creada por el poseedor de la clave privada correspondiente.

Gestión de Claves​

Exportación Controlada​

func (qs *QuantumSigner) ExportPrivateKey() (string, error) {
    privKeyBytes, err := qs.privateKey.MarshalBinary()
    if err != nil {
        return "", err
    }
    if len(privKeyBytes) == 0 {
        return "", errors.New("clave privada no inicializada")
    }
    return hex.EncodeToString(privKeyBytes), nil
}

La exportación de claves privadas está permitida solo para fines de génesis y configuración inicial, nunca para uso operativo normal.

Importación Determinística​

func ImportPrivateKey(hexKey string) (*QuantumSigner, error) {
    privKeyBytes, err := hex.DecodeString(hexKey)
    if err != nil {
        return nil, err
    }

    var privateKey mldsa65.PrivateKey
    err = privateKey.UnmarshalBinary(privKeyBytes)
    if err != nil {
        return nil, err
    }

    publicKey := extractPublicKeyFromPrivate(&privateKey)
    pubKeyBytes, err := publicKey.MarshalBinary()
    if err != nil {
        return nil, err
    }

    address := GenerateQuantumHashHex(pubKeyBytes)

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

La importación reconstruye completamente el firmador desde la clave privada, derivando la clave pública y la dirección.

Generación Determinística​

FromSeed: Creación Reproducible​

func FromSeed(seed []byte) (*QuantumSigner, error) {
    seedRng := &seedRand{seed: hashSeed(seed)}
    publicKey, privateKey, err := mldsa65.GenerateKey(seedRng)
    if err != nil {
        return nil, err
    }

    pubKeyBytes, err := publicKey.MarshalBinary()
    if err != nil {
        return nil, err
    }

    address := GenerateQuantumHashHex(pubKeyBytes)

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

Esta función permite crear firmadores idénticos desde la misma semilla, útil para testing y configuración reproducible.

Funciones de Soporte​

GenerateQuantumHash: El Hash Post-Cuántico​

func GenerateQuantumHash(data []byte) []byte {
    sponge := newSpongeHash()
    sponge.absorb(data)
    return sponge.squeeze(32)
}

Implementa una función hash estilo esponja que simula resistencia cuántica sin depender de algoritmos externos.

QuantumKeyDerivation: Derivación de Claves​

func QuantumKeyDerivation(seed []byte, info []byte) []byte {
    combined := append(seed, info...)
    result := GenerateQuantumHash(combined)
    for i := 0; i < 1000; i++ {
        result = GenerateQuantumHash(append(result, byte(i)))
    }
    return result
}

Deriva claves seguras mediante múltiples iteraciones de hash, proporcionando entropía adicional.

Seguridad por Diseño​

Aislamiento de Claves​

Cada QuantumSigner mantiene sus claves completamente privadas, sin acceso externo a las claves privadas después de la inicialización.

Validación Constante​

Todas las operaciones validan el estado de las claves antes de proceder, previniendo operaciones con claves no inicializadas.

Comparación Segura​

func SecureCompare(a, b []byte) bool {
    if len(a) != len(b) {
        return false
    }

    var result byte
    for i := range a {
        result |= a[i] ^ b[i]
    }

    return result == 0
}

Compara datos de forma segura contra ataques de timing, esencial para operaciones criptográficas.

Integración con el Sistema​

Interfaz Signer​

type Signer interface {
    Sign(data []byte) ([]byte, error)
    PublicKey() ([]byte, error)
    Address() string
    ExportPrivateKey() (string, error)
}

El QuantumSigner implementa esta interfaz, permitiendo su uso polimórfico en todo el sistema.

Factory Pattern​

func NewSignerFactory(tipo, dataDir, passphrase string) (Signer, error) {
    return NewQuantumSigner()
}

Por defecto, el sistema usa exclusivamente QuantumSigner, asegurando criptografía post-cuántica universal.

El Rol en la Arquitectura​

Firmas de Transacciones​

Cada transacción en KodeChain lleva la firma del remitente, verificable por cualquier nodo usando solo la clave pública.

Validación de Bloques​

Los validadores firman bloques completos, permitiendo a la red verificar la autenticidad de cada bloque minado.

Autenticación de Mensajes​

Mensajes P2P entre nodos pueden ser firmados para prevenir spoofing y ataques man-in-the-middle.

Identidad de Nodos​

Cada nodo tiene una identidad criptográfica única derivada de su clave pública, permitiendo reputación y confianza.

El Futuro de la Seguridad​

Resistencia Cuántica Garantizada​

ML-DSA-65 proporciona seguridad contra ataques cuánticos hasta 2030 y más allá, según las especificaciones NIST.

Sin Dependencias Clásicas​

El sistema no usa ningún algoritmo criptográfico clásico (RSA, ECDSA, AES), asegurando pureza post-cuántica.

Escalabilidad​

Las claves de 1952 bytes (pública) y 4032 bytes (privada) son manejables para aplicaciones modernas.

El Arte de la Firma Cuántica​

Cada firma creada por el QuantumSigner es una declaración matemática de autenticidad que sobrevive no solo a los ataques actuales, sino a los que vendrán. Es la garantía de que en un mundo de computadoras cuánticas, KodeChain mantendrá su integridad.

Desde la generación inicial de claves hasta la verificación final de firmas, cada paso está diseñado para crear confianza digital que trasciende las limitaciones de la computación clásica. El QuantumSigner no es solo código; es la vanguardia de la seguridad digital del mañana.