Create signatures using a hybrid/post-quantum method

[apierr]

Stato Attuale vs Obiettivo Finale

✅ Cosa Abbiamo Fatto Finora (Infrastructure Setup)

┌─────────────────────────────────────┐
│ FASE 1: INFRASTRUTTURA (COMPLETA)  │
└─────────────────────────────────────┘

1. ✅ Creato stub provider HYBRID
2. ✅ Modificato Dockerfile per compilare peer custom
3. ✅ Registrato provider nel factory BCCSP
4. ✅ Configurato Docker Compose per usare HYBRID

RISULTATO: Il peer si avvia e "riconosce" il provider HYBRID
           MA internamente usa solo ECDSA (delegazione a SW)

❌ Cosa Manca (Cryptography Implementation)

┌─────────────────────────────────────┐
│ FASE 2: ALGORITMI PQC (DA FARE)    │
└─────────────────────────────────────┘

Attualmente in bccsp/hybrid/hybrid.go:

func (h *HybridBCCSP) Sign(...) {
    return h.sw.Sign(...)  // ← DELEGA A ECDSA!
}

Serve implementare:

func (h *HybridBCCSP) Sign(...) {
    // 1. Firma con ECDSA
    ecdsaSig := h.sw.Sign(...)
    
    // 2. Firma con PQC (es. Dilithium)
    pqcSig := h.pqc.Sign(...)
    
    // 3. Combina le firme
    return combine(ecdsaSig, pqcSig)
}

---

Passi Mancanti per PQC Completo

FASE 2A: Integrazione Libreria PQC (2-3 giorni)

# 1. Aggiungi dipendenza liboqs-go (libreria PQC)
go get github.com/open-quantum-safe/liboqs-go/oqs

# 2. Modifica bccsp/hybrid/hybrid.go per includere:
- Inizializzazione algoritmo Dilithium/Falcon
- Key generation PQC
- Sign/Verify PQC

# 3. Implementa schema hybrid:
- Doppia firma (ECDSA + PQC)
- Doppia verifica
- Formato di serializzazione combinato

FASE 2B: Key Management (1-2 giorni)

Problema: I certificati MSP esistenti sono ECDSA puri

Soluzione:
1. Generare nuove chiavi hybrid (ECDSA + Dilithium)
2. Modificare struttura MSP per supportare dual keys
3. Aggiornare cryptogen o script di generazione certificati

FASE 2C: Modifiche al Protocollo Fabric (3-5 giorni)

Fabric assume firme ECDSA in molti punti:

1. Endorsement signatures
2. Transaction signatures  
3. Block signatures
4. Configuration updates

Serve modificare:
- protobuf definitions (se formato firma cambia)
- signature verification in validazione blocchi
- chaincode endorsement flow

FASE 2D: Testing & Validation (2-3 giorni)

1. Unit test per HYBRID provider
2. Integration test end-to-end
3. Performance benchmarking (obiettivo del progetto!)
4. Verifica interoperabilità con baseline ECDSA

---

Timeline Realistica

┌────────────────────────────────────────────────┐
│ MILESTONE                      │ TEMPO         │
├────────────────────────────────┼───────────────┤
│ ✅ Infrastructure Setup        │ Completato    │
│ ⏳ PQC Library Integration     │ 2-3 giorni    │
│ ⏳ Hybrid Key Generation       │ 1-2 giorni    │
│ ⏳ Protocol Modifications      │ 3-5 giorni    │
│ ⏳ Testing & Benchmarking      │ 2-3 giorni    │
├────────────────────────────────┼───────────────┤
│ TOTALE                         │ 8-13 giorni   │
└────────────────────────────────────────────────┘

---

Prossimo Passo Concreto

Opzione 1: Implementazione Minimale (Proof of Concept)

// bccsp/hybrid/hybrid.go - versione POC

import (
    "github.com/open-quantum-safe/liboqs-go/oqs"
)

func (h *HybridBCCSP) Sign(k bccsp.Key, digest []byte, opts bccsp.SignerOpts) ([]byte, error) {
    // Firma ECDSA
    ecdsaSig, err := h.sw.Sign(k, digest, opts)
    if err != nil {
        return nil, err
    }
    
    // Firma PQC (Dilithium3)
    signer := oqs.Signature{}
    defer signer.Clean()
    signer.Init("Dilithium3", nil)
    
    pqcSig, err := signer.Sign(digest)
    if err != nil {
        return nil, err
    }
    
    // Concatena le firme (formato semplice)
    combined := append(ecdsaSig, pqcSig...)
    return combined, nil
}

Opzione 2: Approccio Incrementale

1. Prima implementa solo firma PQC (no hybrid)
2. Testa con singolo algoritmo (es. Dilithium)
3. Poi aggiungi ECDSA in parallelo
4. Infine benchmark comparativo

---

Domanda per Te

Quale approccio preferisci?

A. POC veloce: Implementiamo firma hybrid minimale per validare l'approccio (~1-2 giorni)

B. Implementazione completa: Seguiamo tutte le fasi con testing rigoroso (~2 settimane)

C. Solo benchmark ECDSA: Prima completiamo i benchmark con ECDSA baseline, poi aggiungiamo PQC

Oppure vuoi che ti prepari un documento dettagliato con tutti gli step necessari?