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:
- Objašnjavamo ključne koncepte HE‑a relevantne za generiranje sintetičkih podataka.
- Prikazujemo end‑to‑end arhitekturu na rubu koja integrira HE s modernim generatorima temeljanim na difuziji.
- Razmatramo kompromise u performansama, hardversko ubrzanje i strategije troškovno‑efikasnog implementiranja.
- Pružamo praktični Python prototip koristeći Microsoft SEAL biblioteku i lagani difuzijski model.
- Ističemo najbolje sigurnosne prakse i implikacije usklađenosti (GDPR, HIPAA, 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.
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:
- HE Encoder – Pretvara sirove vektore senzora u šifrate koristeći javni ključ pohranjen na uređaju.
- Encrypted Payload – Serijalizirani šifrat koji se prenosi (ili ostaje lokalno) radi obrade.
- 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).
- Encrypted Synthetic Sample – Izlaz ostaje enkriptiran; po potrebi HE Decoder može se primijeniti u pouzdanom enclaveu za dobivanje plaintext sintetičkih podataka.
- 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
- Linearne operacije – Izravno podržane od CKKS (zbrajanje, skalarnno množenje).
- Nelinearne aktivacije – Zamijenite (\epsilon_\theta) polinomom niskog stupnja (npr. Chebyshev aproksimacija) koji aproksimira izlaz neuronske mreže.
- 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
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
- Pakiranje više uzoraka u jedan šifrat koristeći packed encoding; CKKS može enkriptirati vektore do
N/2slotova. - Lijen rescaling: odgađajte reskaliranje nekoliko množenja kako biste smanjili broj skupih promjena modula.
- 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/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: 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
- Pametni zdravstveni nosivi uređaji – Generiranje sintetičkih uzoraka otkucaja srca za treniranje modela bez otkrivanja pacijentovih vitalnih znakova.
- Industrijski IoT – Stvaranje sintetičkih vibracijskih signala za prediktivno održavanje, čuvajući vlasničke podatke o strojevima.
- 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.