
# Generarea de Date Sintetice Alimentată de Criptarea Homomorfă la Marginea Rețelei

## Introducere

Dispozitivele de margine — camere inteligente, dispozitive purtabile, senzori industriali — colectează fluxuri masive de date personale sau proprietare. Conductele tradiționale mută aceste date brute în cloud pentru curățare, augmentare sau generare de date sintetice, expunându-le la interceptare, încălcări de reglementare și penalități de latență.  

**Criptarea Homomorfă (HE)** oferă o alternativă convingătoare: permite calculul direct pe date criptate, păstrând confidențialitatea în timp ce permite analize sofisticate. Îmbinarea HE cu generatoare de date sintetice pe dispozitiv creează o **conductă de date sintetice cu protecție a confidențialității** care nu dezvăluie niciodată sarcina originală, nici măcar motorului de calcul.

În acest articol vom:

1. Explicăm conceptele de bază ale HE relevante pentru generarea de date sintetice.  
2. Prezentăm o arhitectură completă de margine care integrează HE cu generatoare moderne bazate pe difuzie.  
3. Discutăm compromisurile de performanță, accelerarea hardware și strategiile de implementare rentabile.  
4. Oferim un prototip practic în Python utilizând biblioteca **Microsoft SEAL** și un model de difuzie ușor.  
5. Evidențiem cele mai bune practici de securitate și implicațiile de conformitate ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Ideea principală:** Prin criptarea citirilor senzorilor brute înainte să părăsească dispozitivul și prin efectuarea generării de date sintetice integral în domeniul criptat, organizațiile pot atinge **sinteză de date zero‑knowledge** — dispozitivul de margine nu cunoaște niciodată datele brute, iar consumatorii de jos în lanț primesc doar înregistrări sintetice, sigure din punct de vedere al confidențialității.

---

## 1. De ce Criptarea Homomorfă pentru Date Sintetice?

| Provocare | Abordare Tradițională | Generare Sintetică cu HE |
|-----------|----------------------|--------------------------|
| **Expunerea datelor** | Date brute transmise în cloud sau la serverul central | Datele rămân criptate end‑to‑end |
| **Conformitate reglementară** | Necesită consimțământ extins al subiecților de date, audituri | Criptarea satisface protecția „data‑in‑use” |
| **Latență** | Round‑trip către cloud adaugă secunde până la minute | Calculul pe dispozitiv elimină întârzierea de rețea |
| **Încredere** | Necesită încredere în mediul de procesare terț | Dovadă zero‑knowledge: procesorul nu poate vedea textul clar |

HE suportă **adunare** și **înmulțire** pe texturi, permițând algebră liniară, operații pe matrici și chiar aproximări neliniare necesare modelelor generative moderne. În timp ce criptarea homomorfă completă (FHE) poate evalua circuite arbitrare, **criptarea homomorfă oarecum (SHE)** este adesea suficientă pentru generatoarele bazate pe difuzie când este combinată cu aproximări inteligente.

---

## 2. Planul Arhitectural

Mai jos este o diagramă Mermaid de nivel înalt care ilustrează fluxul de date.

```mermaid
flowchart LR
    A["Senzor de Margine"] --> B["Codor HE"]
    B --> C["Pachet Criptat"]
    C --> D["Motor de Difuzie cu HE"]
    D --> E["Mostră Sintetică Criptată"]
    E --> F["Decodor HE (opțional)"]
    F --> G["Consumator de Date Sintetice"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Componente:**

1. **Codor HE** – Convertește vectorii senzorului brut în text criptat utilizând o cheie publică stocată pe dispozitiv.  
2. **Pachet Criptat** – Text criptat serializat transmis (sau păstrat local) pentru procesare.  
3. **Motor de Difuzie cu HE** – Un model de difuzie ușor ale cărui nuclee aritmetice sunt rescrise pentru a opera pe texturi criptate (adunare, înmulțire scalară și aproximări polinomiale pentru funcții neliniare).  
4. **Mostră Sintetică Criptată** – Ieșirea rămâne criptată; opțional, un **Decodor HE** poate fi aplicat într-un enclave de încredere pentru a obține date sintetice în clar.  
5. **Consumator de Date Sintetice** – Servicii AI ulterioare (de ex., antrenarea modelelor, analiză) care primesc doar înregistrări sintetice și protejate.

---

## 3. Fundamente Criptografice

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

Majoritatea schemelor HE moderne (BFV, CKKS, BGV) se bazează pe problema RLWE. Pentru generarea de date sintetice alegem de obicei **CKKS** deoarece suportă aritmetică aproximativă pe numere reale — o potrivire naturală pentru modelele de difuzie care lucrează cu tensori în virgulă mobilă.

Parametri tipici:

| Parametru | Valoare tipică | Impact |
|-----------|----------------|--------|
| Gradul modulului polinomial (N) | 2^14 (16384) | Determină dimensiunea textului și nivelul de securitate |
| Factor de scalare (Δ) | 2^40 | Controlează precizia aproximării în virgulă mobilă |
| Modulul textului (q) | 2^180 | Afectează bugetul de zgomot și adâncimea calculului |

### 3.2 Gestionarea Zgomotului

Fiecare operație homomorfă adaugă zgomot textului. Pașii de difuzie implică multe înmulțiri; de aceea trebuie să **relinearizăm** și să **redimensionăm** (rescale) după fiecare pas pentru a menține zgomotul în limite acceptabile. Arhitectura folosește **bootstrapping** doar când bugetul de zgomot amenință să se depășească, lucru rar pentru conducte de difuzie superficiale (≤ 10 pași).

---

## 4. Re‑ingineria Difuziei pentru Domeniul Criptat

### 4.1 Recapitulare Difuzie Standard

Un model de difuzie denoisează iterativ o variabilă latentă \(x_t\) utilizând funcția de scor învățată \(\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
\]

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

### 4.2 Strategie de Aproximare Criptată

1. **Operații liniare** – suportate direct de CKKS (adunare, înmulțire scalară).  
2. **Activare neliniară** – înlocuim \(\epsilon_\theta\) cu un **polinom de grad scăzut** (de ex., aproximare Chebyshev) care imită ieșirea rețelei neurale.  
3. **Injectarea de zgomot aleator** – generăm zgomot în afara domeniului criptat, îl criptăm și îl adăugăm homomorf.

Actualizarea criptată devine:

\[
\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)
\]

unde \(c_1, c_2\) sunt constante de scalare deduse din \(\alpha_t\).

### 4.3 Considerații privind Dimensiunea Modelului

- **Compresie parametri**: Folosiți **distilare de cunoștințe** pentru a micșora modelul profesor într-un student de 1‑2 MB care se încadrează în bugetul de polinom.  
- **Cuantizare**: Cuantizarea la 8 biți reduce dimensiunea textului și accelerează înmulțirea homomorfă.

---

## 5. Implementare Prototip

Mai jos este un prototip minimal în Python care demonstrează difuzia criptată pe un set de date sintetic 2‑D. Folosește **Microsoft SEAL** (prin `seal‑python`) și o funcție de scor polinomială de tip „toy”.

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

# -------------------- Configurare 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)

# -------------------- Date --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Exemplu de citire de la senzor
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Scor Polinomial (grad 3) --------------------
def poly_score(ct):
    # Aproximăm o rețea neurală mică: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Coeficienți învățați exemplu
    # 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)

    # Aliniere scale
    # (Presupunem că toate texturile au acum același scale după rescaling)

    # Combinație liniară
    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 Pas de Difuzie --------------------
def diffusion_step(ct, t):
    # Constante simplificate pentru demonstrație
    c1 = 0.9
    c2 = 0.1

    # Codificăm constantele ca texte
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Calculăm scorul
    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)

    # Combinăm
    evaluator.add(term1, term2, term1)
    return term1

# Executăm 5 pași de difuzie criptată
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Decriptăm mostra sintetică finală (opțional)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Mostră sintetică (decriptată):", synthetic)
```

**Explicație a prototipului**

- **Generare chei**: Configurăm CKKS cu un grad de polinom de 16384, oferind ~128‑bit securitate.  
- **Codificare & criptare**: Vectorul senzorului brut este codificat și criptat.  
- **Scor polinomial**: Înlocuiește rețeaua neurală cu un polinom cubic, evaluabil homomorf.  
- **Pas de difuzie**: Efectuează o iterație de denoising utilizând adunare și înmulțire homomorfă.  
- **Gestionarea zgomotului**: După fiecare înmulțire aplicăm **relinearizare** și **rescaling** pentru a menține bugetul de zgomot.  
- **Decriptare**: Demonstrează că textul final poate fi decriptat într-o mostră sintetică; în producție decriptarea ar avea loc doar într-un enclave de încredere sau ar fi omisă dacă consumatorii acceptă date criptate.

---

## 6. Performanță și Accelerare Hardware

| Platformă | Latență medie per pas de difuzie (ms) | Amprentă memorie (MB) | Observații |
|-----------|--------------------------------------|-----------------------|------------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Bază, fără accelerare |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | Nucleele GPU pentru NTT accelerează înmulțirile |
| Intel Xeon cu AVX‑512 | 60 | 130 | NTT vectorizat și relinearizare paralelă |
| Google Edge TPU (bibliotecă HE personalizată) | 38 | 110 | Experimental, exploatează operații matriciale TPU pentru evaluarea polinomială |

**Sfaturi pentru producție**

1. **Împachetare loturi**: Criptați mai multe mostre într-un singur text utilizând **codificarea împachetată**; CKKS poate cripta vectori de până la `N/2` sloturi.  
2. **Redimensionare leneșă**: Amânați redimensionarea (rescale) până după câteva înmulțiri pentru a reduce numărul de comutări de modul costisitoare.  
3. **Acceleratoare FPGA pentru NTT**: Folosiți acceleratoare FPGA (ex. Xilinx Zynq) pentru dispozitive ultra‑low‑power la margine.

---

## 7. Listă de Verificare pentru Securitate și Conformitate

- **Managementul cheilor**: Stocați cheile publice pe dispozitiv; păstrați cheile secrete într-un enclave de încredere sau HSM. Rotați cheile la fiecare 90 de zile.  
- **Dovezi zero‑knowledge**: Generați o dovadă concisă că mostra sintetică a fost derivată dintr-un proces de difuzie valid fără a dezvălui datele subiacente.  
- **Jurnal de audit**: Înregistrați hash‑urile operațiunilor criptate (ex. SHA‑256 al textului) pe un registru imuabil (blockchain) pentru audituri de reglementare.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Deoarece datele personale brute nu părăsesc dispozitivul în clar, conducta satisface protecția „data‑in‑use”, simplificând evaluările de impact asupra protecției datelor (DPIA).  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: PHI criptat procesat sub HE este considerat un set de date **de‑identificat** conform metodei „expert determination”, cu condiția ca cheia de decriptare să fie strict controlată.

---

## 8. Cazuri de Utilizare în Lumea Reală

1. **Dispozitive medicale purtabile inteligente** – Generați modele sintetice de ritm cardiac pentru antrenarea modelelor fără a expune semnalele pacientului.  
2. **IoT industrial** – Produceți semnături sintetice de vibrații pentru întreținere predictivă păstrând datele proprietare ale mașinilor criptate.  
3. **Vehicule autonome** – Creați noruri de puncte LIDAR sintetice la margine pentru rafinarea continuă a modelului fără a partaja fluxurile brute de senzori.

---

## 9. Direcții Viitoare

- **HE‑MPC hibrid**: Combinați criptarea homomorfă cu calculul securizat multi‑parte (MPC) pentru a permite generarea colaborativă de date sintetice între mai multe noduri de margine.  
- **Rețele polinomiale dinamice**: Utilizați **Neural Architecture Search (NAS)** pentru a descoperi automat aproximări polinomiale de grad scăzut care echilibrează acuratețea și costul homomorf.  
- **Criptare rezistentă la cuantum**: Explorați scheme bazate pe rețele latice care rămân sigure în fața adversarilor post‑cuantic, asigurând conformitatea pe termen lung pentru infrastructuri critice.

---

## Vezi De asemenea

- [Criptarea Homomorfă pentru Învățare Automată – Documentația Microsoft SEAL](https://github.com/microsoft/SEAL)  
- [Generarea de Date Sintetice cu Protecție a Confidențialității – Cadru de Management al Riscului AI NIST](https://www.nist.gov/ai)  
- [Dovezi Zero‑Knowledge pentru Calcul Criptat – Comunitatea ZKProof](https://zkproof.org)