
# Generiranje sintetičkih podataka na rubu uz pomoć homomorfne enkripcije

## Uvod

Uređaji na rubu — pametne kamere, nosive tehnologije, industrijski senzori — prikupljaju masivne tokove osobnih ili vlasničkih podataka. Tradicionalni pipeline‑i šalju ove sirove podatke u oblak radi čišćenja, augmentacije ili generiranja sintetičkih podataka, čime ih izlažu presretanju, regulatornim prekršajima i kašnjenjima.  

**Homomorfna enkripcija (HE)** nudi privlačnu alternativu: omogućuje izračune izravno na enkriptiranim podacima, čuvajući povjerljivost, a istovremeno omogućuje sofisticiranu analitiku. Spoj HE‑a s generatorima sintetičkih podataka na uređaju stvara **pipeline za sintetičke podatke uz očuvanje privatnosti** koji nikada ne otkriva izvorni payload, čak ni samom računalu.

U ovom članku:

1. Objašnjavamo ključne koncepte HE‑a relevantne za generiranje sintetičkih podataka.  
2. Prikazujemo end‑to‑end arhitekturu na rubu koja integrira HE s modernim generatorima temeljanim na difuziji.  
3. Razmatramo kompromise u performansama, hardversko ubrzanje i strategije troškovno‑efikasnog implementiranja.  
4. Pružamo praktični Python prototip koristeći **Microsoft SEAL** biblioteku i lagani difuzijski model.  
5. Ističemo najbolje sigurnosne prakse i implikacije usklađenosti ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Ključna poanta:** Šifriranjem sirovih očitanja senzora prije nego što ikada napuste uređaj i izvođenjem generiranja sintetičkih podataka u potpunosti u enkriptiranom domenu, organizacije mogu postići **zero‑knowledge sintezu podataka** — uređaj na rubu nikada ne vidi sirove podatke, a krajnji korisnici primaju samo sintetičke, privatno‑sigurne zapise.

---

## 1. Zašto homomorfna enkripcija za sintetičke podatke?

| Izazov | Tradicionalni pristup | HE‑om omogućen generiranje sintetičkih podataka |
|--------|----------------------|-----------------------------------------------|
| **Izloženost podataka** | Sirovi podaci se prenose u oblak ili centralni poslužitelj | Podaci ostaju enkriptirani end‑to‑end |
| **Regulatorna usklađenost** | Potrebna je opsežna suglasnost subjekata podataka, revizije | Enkripcija zadovoljava zaštitu “podataka u upotrebi” |
| **Latencija** | Povratni put do oblaka dodaje sekunde do minute | Izračuni na uređaju uklanjaju mrežna kašnjenja |
| **Povjerenje** | Potrebno je povjerenje u treću stranu za obradu | Zero‑knowledge dokaz: procesor ne može vidjeti plaintext |

HE podržava **zbrajanje** i **množenje** nad šifratima, omogućujući linearnu algebru, operacije nad matricama i čak nelinearne aproksimacije potrebne za moderne generativne modele. Dok potpuno homomorfna enkripcija (FHE) može evaluirati proizvoljne sklopove, **nepotpuno homomorfna enkripcija (SHE)** često je dovoljna za difuzijske generatore kada se kombinira s pametnim aproksimacijama.

---

## 2. Arhitektonski plan

Dolje je prikazan visokorazinski Mermaid dijagram koji ilustrira tok podataka.

```mermaid
flowchart LR
    A["Edge Sensor"] --> B["HE Encoder"]
    B --> C["Encrypted Payload"]
    C --> D["HE‑Enabled Diffusion Engine"]
    D --> E["Encrypted Synthetic Sample"]
    E --> F["HE Decoder (optional)"]
    F --> G["Synthetic Data Consumer"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponente:**

1. **HE Encoder** – Pretvara sirove vektore senzora u šifrate koristeći javni ključ pohranjen na uređaju.  
2. **Encrypted Payload** – Serijalizirani šifrat koji se prenosi (ili ostaje lokalno) radi obrade.  
3. **HE‑Enabled Diffusion Engine** – Lagani difuzijski model čiji su aritmetički kernel‑i prepisani da rade na šifratima (zbrajanje, skalarnno množenje i polinomske aproksimacije za nelinearne funkcije).  
4. **Encrypted Synthetic Sample** – Izlaz ostaje enkriptiran; po potrebi **HE Decoder** može se primijeniti u pouzdanom enclaveu za dobivanje plaintext sintetičkih podataka.  
5. **Synthetic Data Consumer** – Downstream AI servisi (npr. treniranje modela, analitika) koji primaju samo sintetičke, privatno‑sigurne zapise.

---

## 3. Kriptografske osnove

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

Većina modernih HE shema (BFV, CKKS, BGV) temelji se na RLWE problemu. Za generiranje sintetičkih podataka najčešće biramo **CKKS** jer podržava aproksimativnu aritmetiku nad realnim brojevima — prirodno uklapanje za difuzijske modele koji rade s floating‑point tenzorima.

Ključni parametri:

| Parametar | Tipična vrijednost | Utjecaj |
|-----------|-------------------|---------|
| Stepen polinoma (N) | 2^14 (16384) | Određuje veličinu šifrata i razinu sigurnosti |
| Skaliranje (Δ) | 2^40 | Kontrolira preciznost aproksimacije floating‑pointa |
| Modulus šifrata (q) | 2^180 | Utječe na budžet šuma i dubinu izračuna |

### 3.2 Upravljanje šumom

Svaka homomorfna operacija dodaje šum šifri. Koraci difuzije uključuju mnogo množenja; stoga moramo **relinearizirati** i **reskalirati** nakon svakog koraka kako bismo šum držali pod kontrolom. Bootstrapping se koristi samo kada budžet šuma prijeti preljevu, što je rijetko za plitke difuzijske pipeline‑e (≤ 10 koraka).

---

## 4. Preuređivanje difuzije za enkriptirani domen

### 4.1 Standardna difuzija u pregledu

Difuzijski model iterativno denoizira latentnu varijablu \(x_t\) koristeći naučenu funkciju skora \(\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
\]

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

### 4.2 Strategija enkriptirane aproksimacije

1. **Linearne operacije** – Izravno podržane od CKKS (zbrajanje, skalarnno množenje).  
2. **Nelinearne aktivacije** – Zamijenite \(\epsilon_\theta\) **polinomom niskog stupnja** (npr. Chebyshev aproksimacija) koji aproksimira izlaz neuronske mreže.  
3. **Ubrizgavanje nasumičnog šuma** – Generirajte šum izvan enkriptiranog domena, enkriptirajte ga i homomorfno dodajte.  

Enkriptirano ažuriranje postaje:

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

gdje su \(c_1, c_2\) skalari izvedeni iz \(\alpha_t\).

### 4.3 Veličina modela

- **Komprimiranje parametara**: Koristite **knowledge distillation** kako biste smanjili učiteljski model na student od 1‑2 MB koji odgovara budžetu polinomskih aproksimacija.  
- **Kvantizacija**: 8‑bit kvantizacija smanjuje veličinu šifrata i ubrzava homomorfno množenje.

---

## 5. Prototip implementacije

Dolje je minimalni Python prototip koji demonstrira enkriptiranu difuziju na sintetičkom 2‑D skupu podataka. Koristi **Microsoft SEAL** (putem `seal‑python`) i jednostavnu polinomsku funkciju skora.

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

# -------------------- HE Setup --------------------
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)

# -------------------- Data --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Primjer očitanja senzora
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynomial Score (degree 3) --------------------
def poly_score(ct):
    # Aproksimacija male neuronske mreže: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Primjer naučenih koeficijenata
    # 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)

    # Linear combination
    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

# -------------------- One Diffusion Step --------------------
def diffusion_step(ct, t):
    # Pojednostavljene konstante za demonstraciju
    c1 = 0.9
    c2 = 0.1

    # Skaliranje konstanti u plaintext
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Izračun skora
    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)

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

# Pokreni 5 enkriptiranih difuzijskih koraka
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Dešifriraj finalni sintetički uzorak (opcionalno)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Sintetički (dešifrirani) uzorak:", synthetic)
```

**Objašnjenje prototipa**

- **Generiranje ključeva**: Postavlja CKKS s polinomskim stepenom 16384, pružajući ~128‑bit sigurnost.  
- **Kodiranje & enkripcija**: Vektor senzora se kodira i enkriptira.  
- **Polinomski skor**: Zamjenjuje neuronsku mrežu kubnim polinomom koji se može evaluirati homomorfno.  
- **Korak difuzije**: Izvodi pojedinačnu iteraciju denoisinga koristeći homomorfno zbrajanje i množenje.  
- **Upravljanje šumom**: Nakon svakog množenja vršimo **relinearizaciju** i **reskaliranje** kako bismo održali budžet šuma.  
- **Dešifriranje**: Pokazuje da se iz šifrata može dobiti sintetički uzorak; u produkciji dešifriranje se obavlja samo u pouzdanom enclaveu ili se izostavlja ako krajnji korisnici prihvaćaju enkriptirane podatke.

---

## 6. Performanse i hardversko ubrzanje

| Platforma | Prosječna latencija po koraku difuzije (ms) | Memorijski otisak (MB) | Napomene |
|-----------|--------------------------------------------|------------------------|----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Osnovno, bez ubrzanja |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | GPU kerneli za NTT ubrzavaju množenje |
| Intel Xeon s AVX‑512 | 60 | 130 | Vektorizirani NTT i paralelna relinearizacija |
| Google Edge TPU (prilagođena HE lib) | 38 | 110 | Eksperimentalno, koristi TPU matricne operacije za polinomske izračune |

**Savjeti za produkciju**

1. **Pakiranje više uzoraka** u jedan šifrat koristeći **packed encoding**; CKKS može enkriptirati vektore do `N/2` slotova.  
2. **Lijen rescaling**: odgađajte reskaliranje nekoliko množenja kako biste smanjili broj skupih promjena modula.  
3. **FPGA‑temeljeni NTT akceleratori** za ultra‑niskopotrosne uređaje na rubu (npr. Xilinx Zynq).

---

## 7. Sigurnosna i usklađenostna kontrolna lista

- **Upravljanje ključevima**: Javni ključevi pohranite na uređaju; tajne ključeve držite u sigurnom enclaveu ili HSM‑u. Rotirajte ključeve svakih 90 dana.  
- **Zero‑knowledge dokazi**: Generirajte kratki dokaz da je sintetički uzorak proizveden valjanim difuzijskim procesom bez otkrivanja podataka.  
- **Audit trail**: Zapisujte hash‑ove enkriptiranih operacija (npr. SHA‑256 šifrata) u nepromjenjivi ledger (blockchain) za regulatorne revizije.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Budući da sirovi osobni podaci nikada ne napuste uređaj u plaintextu, pipeline zadovoljava zaštitu “podataka u upotrebi”, što pojednostavljuje DPIA.  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: Enkriptirani PHI obrađen pod HE‑om smatra se **de‑identificiranim** pod metodom “expert determination”, pod uvjetom da je ključ za dešifriranje strogo kontroliran.

---

## 8. Primjeri iz stvarnog svijeta

1. **Pametni zdravstveni nosivi uređaji** – Generiranje sintetičkih uzoraka otkucaja srca za treniranje modela bez otkrivanja pacijentovih vitalnih znakova.  
2. **Industrijski IoT** – Stvaranje sintetičkih vibracijskih signala za prediktivno održavanje, čuvajući vlasničke podatke o strojevima.  
3. **Autonomna vozila** – Generiranje sintetičkih LIDAR točaka na rubu za kontinuirano usavršavanje modela bez dijeljenja sirovih senzorskih podataka.

---

## 9. Budući smjerovi

- **Hibridni HE‑MPC**: Kombinirajte homomorfnu enkripciju s sigurnim višestranim izračunom (MPC) kako biste omogućili kolaborativno generiranje sintetičkih podataka među više uređaja na rubu.  
- **Dinamične polinomske mreže**: Upotrijebite **Neural Architecture Search (NAS)** za automatsko otkrivanje polinomskih aproksimacija niskog stupnja koje balansiraju točnost i trošak homomorfnih operacija.  
- **Kvantno‑otporna HE**: Istražujte sheme temeljene na rešetkama koje ostaju sigurne protiv post‑kvantnih napada, osiguravajući dugoročnu usklađenost za kritične infrastrukture.

---

## Pogledajte i

- [Homomorphic Encryption for Machine Learning – Microsoft SEAL Documentation](https://github.com/microsoft/SEAL)  
- [Privacy‑Preserving Synthetic Data Generation – NIST AI Risk Management Framework](https://www.nist.gov/ai)  
- [Zero‑Knowledge Proofs for Encrypted Computation – ZKProof Community](https://zkproof.org)