
# Generazione di Dati Sintetici Alimentata da Crittografia Omomorfica al Bordo

## Introduzione

I dispositivi edge—telecamere intelligenti, indossabili, sensori industriali—raccolgono flussi massivi di dati personali o proprietari. Le pipeline tradizionali spostano questi dati grezzi al cloud per pulizia, aumento o generazione di dati sintetici, esponendoli a intercettazioni, violazioni normative e penalità di latenza.  

**La Crittografia Omomorfica (HE)** offre un’alternativa convincente: permette il calcolo direttamente su dati crittografati, preservando la riservatezza pur consentendo analisi sofisticate. Unire HE con generatori di dati sintetici sul dispositivo crea una **pipeline di dati sintetici rispettosa della privacy** che non rivela mai il payload originale, nemmeno al motore di calcolo stesso.

In questo articolo:

1. Spieghiamo i concetti fondamentali di HE rilevanti per la generazione di dati sintetici.  
2. Delineiamo un’architettura edge end‑to‑end che integra HE con generatori moderni basati su diffusione.  
3. Discutiamo i compromessi di prestazione, l’accelerazione hardware e le strategie di distribuzione economicamente efficienti.  
4. Forniamo un prototipo pratico in Python usando la libreria **Microsoft SEAL** e un modello di diffusione leggero.  
5. Evidenziamo le migliori pratiche di sicurezza e le implicazioni di conformità ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Conclusione chiave:** Crittografando le letture dei sensori prima che lascino il dispositivo e realizzando la generazione di dati sintetici interamente nel dominio crittografato, le organizzazioni possono ottenere **sintesi di dati a conoscenza zero**—il dispositivo edge non apprende mai i dati grezzi e i consumatori downstream ricevono solo record sintetici, sicuri per la privacy.

---

## 1. Perché la Crittografia Omomorfica per i Dati Sintetici?

| Sfida | Approccio Tradizionale | Generazione Sintetica Abilitata da HE |
|-----------|----------------------|---------------------------------|
| **Esposizione dei dati** | Dati grezzi trasmessi a cloud o server centrale | I dati rimangono crittografati end‑to‑end |
| **Conformità normativa** | Richiede ampi consensi dei soggetti, audit | La crittografia soddisfa la protezione “data‑in‑use” |
| **Latenza** | Il round‑trip al cloud aggiunge secondi o minuti | Il calcolo sul dispositivo elimina il ritardo di rete |
| **Fiducia** | Richiede fiducia nell’ambiente di elaborazione di terze parti | Prova a conoscenza zero: il processore non può vedere il plaintext |

HE supporta **addizione** e **moltiplicazione** su ciphertext, consentendo algebra lineare, operazioni matriciali e anche approssimazioni non lineari necessarie ai moderni modelli generativi. Mentre la crittografia omomorfica completamente (FHE) può valutare circuiti arbitrari, **la crittografia omomorfica parzialmente (SHE)** è spesso sufficiente per generatori basati su diffusione quando combinata con approssimazioni intelligenti.

---

## 2. Progetto Architetturale

Di seguito è riportato un diagramma Mermaid ad alto livello che illustra il flusso dei dati.

```mermaid
flowchart LR
    A["Sensore Edge"] --> B["Codificatore HE"]
    B --> C["Payload Crittografato"]
    C --> D["Motore di Diffusione HE‑Abilitato"]
    D --> E["Campione Sintetico Crittografato"]
    E --> F["Decodificatore HE (opzionale)"]
    F --> G["Consumatore di Dati Sintetici"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Componenti:**

1. **Codificatore HE** – Converte i vettori sensore grezzi in ciphertext usando una chiave pubblica memorizzata sul dispositivo.  
2. **Payload Crittografato** – Ciphertext serializzato trasmesso (o mantenuto localmente) per l’elaborazione.  
3. **Motore di Diffusione HE‑Abilitato** – Un modello di diffusione leggero i cui kernel aritmetici sono riscritti per operare su ciphertext (addizione, moltiplicazione scalare e approssimazioni polinomiali per funzioni non lineari).  
4. **Campione Sintetico Crittografato** – L’output rimane crittografato; facoltativamente, un **Decodificatore HE** può essere applicato in un enclave fidato per ottenere i dati sintetici in plaintext.  
5. **Consumatore di Dati Sintetici** – Servizi AI downstream (es. addestramento modelli, analytics) che ricevono solo record sintetici, rispettosi della privacy.

---

## 3. Fondamenti Crittografici

### 3.1 Ring‑Learning With Errors (RLWE)

La maggior parte degli schemi HE moderni (BFV, CKKS, BGV) si basa sul problema RLWE. Per la generazione di dati sintetici scegliamo tipicamente **CKKS** perché supporta aritmetica approssimativa su numeri reali—una corrispondenza naturale per i modelli di diffusione che operano su tensori a virgola mobile.

Parametri tipici:

| Parametro | Valore Tipico | Impatto |
|-----------|---------------|--------|
| Grado del polinomio (N) | 2^14 (16384) | Determina la dimensione del ciphertext e il livello di sicurezza |
| Fattore di scaling (Δ) | 2^40 | Controlla la precisione dell’approssimazione floating‑point |
| Modulo del ciphertext (q) | 2^180 | Influisce sul budget di rumore e sulla profondità di calcolo |

### 3.2 Gestione del Rumore

Ogni operazione omomorfica aggiunge rumore al ciphertext. I passi di diffusione coinvolgono molte moltiplicazioni; pertanto dobbiamo **relinearizzare** e **riscalare** dopo ogni passo per mantenere il rumore entro limiti accettabili. L’architettura utilizza il **bootstrapping** solo quando il budget di rumore rischia di esaurirsi, cosa rara per pipeline di diffusione poco profonde (≤ 10 passi).

---

## 4. Riprogettare la Diffusione per il Dominio Crittografato

### 4.1 Riepilogo della Diffusione Standard

Un modello di diffusione denoizza iterativamente una variabile latente \(x_t\) usando una funzione di punteggio appresa \(\epsilon_\theta(x_t, t)\):

\[
x_{t-1} = \frac{1}{\sqrt{\alpha_t}} \left( x_t - \frac{1-\alpha_t}{\sqrt{1-\bar\alpha_t}} \epsilon_\theta(x_t, t) \right) + \sigma_t z
\]

dove \(z \sim \mathcal{N}(0, I)\).

### 4.2 Strategia di Approssimazione Crittografata

1. **Operazioni lineari** – Supportate direttamente da CKKS (addizione, moltiplicazione scalare).  
2. **Attivazione non lineare** – Sostituire \(\epsilon_\theta\) con un **polinomio a basso grado** (es. approssimazione di Chebyshev) che approssima l’output della rete neurale.  
3. **Iniezione di rumore casuale** – Generare rumore **fuori** dal dominio crittografato, crittografarlo e aggiungerlo omomorficamente.  

L’aggiornamento crittografato risultante diventa:

\[
\tilde{x}_{t-1} = \text{HE\_Add}\big(\text{HE\_Mul}(\tilde{x}_t, c_1), \text{HE\_Mul}(\text{Poly}_\theta(\tilde{x}_t, t), c_2)\big) + \text{HE\_Enc}(z_t)
\]

dove \(c_1, c_2\) sono costanti di scaling derivanti da \(\alpha_t\).

### 4.3 Considerazioni sulle Dimensioni del Modello

- **Compressione dei parametri**: Usa **distillazione della conoscenza** per ridurre il modello teacher in uno studente da 1‑2 MB che rientra nel budget polinomiale.  
- **Quantizzazione**: La quantizzazione a 8 bit riduce la dimensione del ciphertext e velocizza la moltiplicazione omomorfica.

---

## 5. Implementazione Prototipo

Di seguito è mostrato un prototipo Python minimale che dimostra la diffusione crittografata su un dataset sintetico 2‑D. Utilizza **Microsoft SEAL** (via `seal-python`) e una funzione di punteggio polinomiale di esempio.

```python
# python
import seal
import numpy as np

# -------------------- Configurazione HE --------------------
parms = seal.EncryptionParameters(seal.scheme_type.ckks)
parms.set_poly_modulus_degree(16384)
parms.set_coeff_modulus(seal.CoeffModulus.Create(16384, [60, 40, 40, 60]))
scale = 2**40

context = seal.SEALContext.Create(parms)
keygen = seal.KeyGenerator(context)
public_key = keygen.public_key()
secret_key = keygen.secret_key()
encryptor = seal.Encryptor(context, public_key)
decryptor = seal.Decryptor(context, secret_key)
evaluator = seal.Evaluator(context)
encoder = seal.CKKSEncoder(context)

# -------------------- Dati --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Esempio di lettura sensore
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Punteggio Polinomiale (grado 3) --------------------
def poly_score(ct):
    # Approssimazione di una piccola rete: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Coefficienti di esempio
    # x
    x = ct
    # x^2
    x2 = seal.Ciphertext()
    evaluator.multiply(x, x, x2)
    evaluator.relinearize_inplace(x2, keygen.relin_keys())
    evaluator.rescale_to_next_inplace(x2)

    # x^3 = x2 * x
    x3 = seal.Ciphertext()
    evaluator.multiply(x2, x, x3)
    evaluator.relinearize_inplace(x3, keygen.relin_keys())
    evaluator.rescale_to_next_inplace(x3)

    # Allineamento scale (assumiamo che tutti i ciphertext condividano lo stesso scale dopo il rescaling)

    # Combinazione lineare
    result = seal.Ciphertext()
    evaluator.multiply_plain(x, seal.Plaintext(str(coeffs[1])), result)
    evaluator.add_plain_inplace(result, seal.Plaintext(str(coeffs[0])))

    tmp = seal.Ciphertext()
    evaluator.multiply_plain(x2, seal.Plaintext(str(coeffs[2])), tmp)
    evaluator.add_inplace(result, tmp)

    tmp = seal.Ciphertext()
    evaluator.multiply_plain(x3, seal.Plaintext(str(coeffs[3])), tmp)
    evaluator.add_inplace(result, tmp)

    return result

# -------------------- Un Passo di Diffusione --------------------
def diffusion_step(ct, t):
    # Costanti semplificate per dimostrazione
    c1 = 0.9
    c2 = 0.1

    # Converti costanti in plaintext
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Calcola punteggio
    score = poly_score(ct)

    # c1 * ct
    term1 = seal.Ciphertext()
    evaluator.multiply_plain(ct, pt_c1, term1)
    evaluator.rescale_to_next_inplace(term1)

    # c2 * score
    term2 = seal.Ciphertext()
    evaluator.multiply_plain(score, pt_c2, term2)
    evaluator.rescale_to_next_inplace(term2)

    # Combina
    evaluator.add(term1, term2, term1)
    return term1

# Esegui 5 passi di diffusione crittografata
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Decripta il campione sintetico finale (opzionale)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Campione sintetico (decriptato):", synthetic)
```

**Spiegazione del prototipo**

- **Generazione delle chiavi**: Configura CKKS con un grado polinomiale 16384, fornendo circa 128 bit di sicurezza.  
- **Encoding & Encryption**: Il vettore sensore grezzo viene codificato e crittografato.  
- **Punteggio Polinomiale**: Sostituisce la rete neurale con un polinomio cubico, valutabile omomorficamente.  
- **Passo di Diffusione**: Esegue una singola iterazione di denoising usando addizione e moltiplicazione omomorfiche.  
- **Gestione del Rumore**: Dopo ogni moltiplicazione eseguiamo **relinearizzazione** e **rescaling** per mantenere il budget di rumore sotto controllo.  
- **Decrittazione**: Dimostra che il ciphertext finale può essere decriptato in un campione sintetico; in produzione la decrittazione avverrebbe solo in un enclave fidato o verrebbe omessa se i consumatori accettano dati crittografati.

---

## 6. Prestazioni & Accelerazione Hardware

| Piattaforma | Latenza Media per Passo di Diffusione (ms) | Occupazione Memoria (MB) | Osservazioni |
|-------------|--------------------------------------------|--------------------------|--------------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Baseline, senza accelerazione |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | Kernel GPU per NTT accelerano le moltiplicazioni |
| Intel Xeon con AVX‑512 | 60 | 130 | NTT vettorizzato e relinearizzazione parallela |
| Google Edge TPU (libreria HE custom) | 38 | 110 | Sperimentale, sfrutta le operazioni matriciali del TPU per la valutazione polinomiale |

**Consigli per la produzione**

1. **Batching**: Accorpa più campioni in un unico ciphertext usando la **packed encoding**; CKKS può crittografare vettori fino a `N/2` slot.  
2. **Rescaling pigro**: Posticipa il rescaling dopo alcune moltiplicazioni per ridurre il numero di costosi cambi di modulo.  
3. **Acceleratori FPGA per NTT**: Utilizza acceleratori basati su FPGA (es. Xilinx Zynq) per dispositivi ultra‑low‑power edge.

---

## 7. Checklist di Sicurezza & Conformità

- **Gestione delle chiavi**: Conserva le chiavi pubbliche sul dispositivo; mantieni le chiavi segrete in un enclave sicuro o HSM. Ruota le chiavi ogni 90 giorni.  
- **Prove a conoscenza zero**: Genera una prova concisa che il campione sintetico è stato derivato da un processo di diffusione valido senza rivelare i dati sottostanti.  
- **Tracciabilità**: Registra hash di operazioni crittografate (es. SHA‑256 del ciphertext) su un registro immutabile (blockchain) per audit normativi.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Poiché i dati personali grezzi non lasciano mai il dispositivo in plaintext, la pipeline soddisfa la protezione “data‑in‑use”, semplificando le Valutazioni d’Impatto sulla Protezione dei Dati (DPIA).  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: I PHI crittografati processati con HE sono considerati **dati de‑identificati** secondo il metodo “expert determination”, a condizione che la chiave di decrittazione sia strettamente controllata.

---

## 8. Casi d'Uso Real‑World

1. **Wearable sanitari intelligenti** – Generano pattern sintetici di frequenza cardiaca per l’addestramento di modelli senza esporre i dati dei pazienti.  
2. **IoT industriale** – Producono firme sintetiche di vibrazioni per la manutenzione predittiva mantenendo segreti i dati proprietari delle macchine.  
3. **Veicoli autonomi** – Creano point cloud LIDAR sintetici al bordo per il continuo affinamento del modello senza condividere feed sensoriali grezzi.

---

## 9. Direzioni Future

- **HE‑MPC ibrido**: Unire la crittografia omomorfica con il calcolo multi‑parte sicuro per abilitare la generazione collaborativa di dati sintetici tra più nodi edge.  
- **Reti Polinomiali Dinamiche**: Utilizzare **Neural Architecture Search (NAS)** per scoprire automaticamente approssimazioni polinomiali a basso grado che bilanciano accuratezza e costo omomorfico.  
- **HE resistente al quantum**: Esplorare schemi basati su reticoli che rimangono sicuri contro avversari post‑quantistici, garantendo conformità a lungo termine per infrastrutture critiche.

---

## Vedi anche

- [Crittografia Omomorfica per Machine Learning – Documentazione Microsoft SEAL](https://github.com/microsoft/SEAL)  
- [Generazione di Dati Sintetici Rispettosi della Privacy – NIST AI Risk Management Framework](https://www.nist.gov/ai)  
- [Prove a Conoscenza Zero per Computazione Crittografata – Comunità ZKProof](https://zkproof.org)