
# Homomorfse Krüpteerimisega Toetatud Sünteetiliste Andmete Loomine Ääreal

## Sissejuhatus

Ääraseadmed — nutikad kaamerad, kantavad seadmed, tööstusandurid — koguvad tohutuid isiklike või omandatud andmete voogusid. Traditsioonilised torujuhtmed saadavad need toorandmed pilve puhastamiseks, täiendamiseks või sünteetiliste andmete loomiseks, paljastades need seeläbi pealtkuulamisele, regulatiivsetele rikkumistele ja latentsuskaristustele.

**Homomorfne Krüpteerimine (HE)** pakub veenvat alternatiivi: see võimaldab arvutusi otse krüpteeritud andmetel, säilitades konfidentsiaalsuse, kuid võimaldades siiski keerukaid analüüse. HE ja seadmesisesed sünteetilised andmegeneraatorid loovad **privaatsust säilitava sünteetilise andmete torujuhtme**, mis ei avalda kunagi algset koormust, isegi mitte arvutusmootorile endale.

Selles artiklis me:

1. Selgitame HE põhikontseptsioone, mis on olulised sünteetiliste andmete loomisel.  
2. Kirjeldame lõpp‑kuni‑lõpp äärealade arhitektuuri, mis ühendab HE‑d kaasaegsete difusioonipõhiste generaatoritega.  
3. Arutame jõudluse kompromisse, riistvaralist kiirendust ja kulutõhusaid juurutusstrateegiaid.  
4. Pakume praktilist Python‑prototüüpi, mis kasutab **Microsoft SEAL**‑raamatukogu ja kerget difusioonimudelit.  
5. Tõstame esile turvalisuse parimaid tavasid ja vastavusnõudeid ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Oluline järeldus:** Krüpteerides toorsensorite lugemised enne, kui need kunagi seadmest lahkuvad, ja teostades sünteetilise andmete loomise täielikult krüpteeritud domeenis, saavad organisatsioonid saavutada **null‑teadmiste andmete süntees** — ääreseade ei õpi kunagi toorandmeid ning allvoodukasutajad saavad ainult sünteetilisi, privaatsust säilitavaid kirjeid.

---

## 1. Miks Homomorfne Krüpteerimine Sünteetiliste Andmete Jaoks?

| Väljakutse | Traditsiooniline Lähenemine | HE‑Toetatud Sünteetiline Loomine |
|-----------|----------------------------|---------------------------------|
| **Andmete lekitamine** | Toorandmed edastatakse pilve või keskserverisse | Andmed jäävad krüpteerituks läbi kogu ahela |
| **Regulatiivne vastavus** | Nõuab ulatuslikku andmesubjektide nõusolekut, auditeid | Krüpteerimine rahuldab “andmete‑kasutamise” kaitset |
| **Latentsus** | Pilve‑sõit lisab sekundeid kuni minuteid | Seadmesisesed arvutused kõrvaldavad võrguviivituse |
| **Usaldus** | Nõuab usaldust kolmanda‑osapoole töötlemiskeskkonna suhtes | Null‑teadmiste tõend: protsessor ei näe selget teksti |

HE toetab **liitmist** ja **korrutamist** krüpteeritud tekstides, võimaldades lineaarset algebrat, maatriksoperatsioone ja isegi mittelineaarseid lähendusi, mida nõuavad kaasaegsed generatiivsed mudelid. Kuigi täielik homomorfne krüpteerimine (FHE) suudab hinnata suvalisi voole, **osaliselt homomorfne krüpteerimine (SHE)** on sageli piisav difusioonipõhiste generaatorite jaoks, kui kombineerida nutikate lähendustega.

---

## 2. Arhitektuuriline Plaan

Allpool on kõrgtaseme Mermaid‑diagramm, mis illustreerib andmevoogu.

```mermaid
flowchart LR
    A["Äärasensor"] --> B["HE Kodeerija"]
    B --> C["Krüpteeritud Koormus"]
    C --> D["HE‑Toetatud Difusioonimootor"]
    D --> E["Krüpteeritud Sünteetiline Näidis"]
    E --> F["HE Dekooder (valikuline)"]
    F --> G["Sünteetilise Andmete Tarbija"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponendid:**

1. **HE Kodeerija** – Teisendab toorsensorite vektorid krüpttekstiks, kasutades seadmes salvestatud avalikku võtit.  
2. **Krüpteeritud Koormus** – Serialiseeritud krüpttekst, mida saab töödelda (või hoida lokaalselt).  
3. **HE‑Toetatud Difusioonimootor** – Kerge difusioonimudel, mille aritmeetilised tuumad on ümberkirjutatud toimima krüpttekstidel (liitmine, skalaarne korrutamine ja polünoomilised lähendused mittelineaarsete funktsioonide jaoks).  
4. **Krüpteeritud Sünteetiline Näidis** – Väljund jääb krüpteerituks; valikuliselt võib **HE Dekooder** rakendada usaldusväärses turvalises keskkonnas, et saada selge sünteetiline andmestik.  
5. **Sünteetilise Andmete Tarbija** – Allvood AI‑teenused (nt mudelite treenimine, analüütika), mis saavad ainult sünteetilisi, privaatsust säilitavaid kirjeid.

---

## 3. Krüptograafilised Alused

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

Enamik tänapäevaseid HE‑skeeme (BFV, CKKS, BGV) põhinevad RLWE‑probleemil. Sünteetiliste andmete loomise jaoks valime tavaliselt **CKKS**, sest see toetab ligikaudset aritmeetikat reaalarvude peal — loogiline sobivus difusioonimudelitega, mis töötavad ujukomaarvuliste tensooridega.

**Olulised parameetrid:**

| Parameeter | Tüüpiline Väärtus | Mõju |
|------------|-------------------|------|
| Polünoomi mooduli aste (N) | 2^14 (16384) | Määrab krüptteksti suuruse ja turvalisuse taseme |
| Skaleerimistegur (Δ) | 2^40 | Kontrollib ujukomaarvude ligikaudse täpsuse |
| Krüptteksti moodul (q) | 2^180 | Mõjutab mürabudjetti ja arvutuste sügavust |

### 3.2 Müra Haldamine

Iga homomorfne operatsioon lisab krüpttekstile müra. Difusioonisammud nõuavad palju korrutamisi; seetõttu peame **relineaarima** ja **reskaaleerima** pärast iga sammu, et hoida müra piirides. **Bootstrapping** on vajalik vaid siis, kui mürabudjet läheneb piirile – see on haruldane lühikeste difusiooniputkide (≤ 10 sammu) puhul.

---

## 4. Diffusiooni Ümberkujundamine Krüpteeritud Domeenis

### 4.1 Standardne Diffusiooni Kokkuvõte

Difusioonimudel iteratiivselt eemaldab müra latentmuutujast \(x_t\) kasutades õpitud skoorifunktsiooni \(\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
\]

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

### 4.2 Krüpteeritud Ligikaudse Strateegia

1. **Lineaarsed operatsioonid** – Otse toetatud CKKS‑i poolt (liitmine, skalaarne korrutamine).  
2. **Mittelineaarsed aktivatsioonid** – Asendame \(\epsilon_\theta\) **madala astme polünoomiga** (nt Chebyshevi lähendus), mis lähendab närvivõrgu väljundit.  
3. **Juhusliku müra lisamine** – Genereerime müra **väljas** krüpteeritud domeenist, krüpteerime selle ja liidame homomorfse tehtega.  

Krüpteeritud uuendus muutub:

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

kus \(c_1, c_2\) on \(\alpha_t\)‑st saadud skaleerimiskonstandid.

### 4.3 Mudeli Suuruse Optimeerimine

- **Parameetrite tihendamine**: Kasuta **teadmiste distilleerimist**, et vähendada õpetaja mudel 1‑2 MB‑ni, mis sobib polünoomilise lähenduse eelarvega.  
- **Kvantiseerimine**: 8‑bitine kvantiseerimine vähendab krüptteksti suurust ja kiirendab homomorfset korrutamist.

---

## 5. Prototüübi Rakendus

Allpool on minimaalne Python‑prototüüp, mis demonstreerib krüpteeritud difusiooni lihtsal 2‑D andmestikul. See kasutab **Microsoft SEAL**‑i (via `seal‑python`) ja lihtsat polünoomilist skoorifunktsiooni.

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

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

# -------------------- Andmed --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Näide sensorite lugemisest
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polünoomiline Skoor (aste 3) --------------------
def poly_score(ct):
    # Ligikaudne väike närvivõrk: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Näidisõppitud koefitsiendid
    # 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)

    # Skaleerime koefitsiendid
    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

# -------------------- Üks Difusioonisamm --------------------
def diffusion_step(ct, t):
    # Lihtsustatud konstandid demonstratsiooniks
    c1 = 0.9
    c2 = 0.1

    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Arvuta skoor
    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)

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

# Käivita 5 krüpteeritud difusioonisammu
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Valikuline dekrüpteerimine (nt usaldusväärses enclavese)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Sünteetiline (dekrüpteeritud) näidis:", synthetic)
```

**Prototüübi selgitus**

- **Võtmete genereerimine**: Seadistab CKKS‑i 16384‑astmelise polünoomi mooduliga, pakkudes ~128‑bitist turvalisust.  
- **Kodeerimine & Krüpteerimine**: Toorsensorite vektor kodeeritakse ja krüpteeritakse.  
- **Polünoomiline Skoor**: Asendab närvivõrgu madala astme polünoomiga, mida saab homomorfsete operatsioonidega hinnata.  
- **Difusioonisamm**: Teostab ühe denoising‑iteratsiooni, kasutades homomorfset liitmist ja korrutamist.  
- **Müra haldamine**: Iga korrutamise järel **relineaarime** ja **reskaaleerime**, et hoida mürabudjet kontrolli all.  
- **Dekrüpteerimine**: Demonstreerib, kuidas lõplik krüpttekst võib dekrüpteerida sünteetiliseks näidiseks; tootmises dekrüpteerimine toimub ainult usaldusväärses enclavese või jäetakse täielikult krüpteerituks.

---

## 6. Jõudlus ja Riistvaraline Kiirendus

| Platvorm | Keskmine viivitus ühe difusioonisammu kohta (ms) | Mälu Jalajälg (MB) | Märkused |
|----------|-----------------------------------------------|--------------------|----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Baastase, kiirenduseta |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | GPU‑tuumad NTT‑kiirenduseks |
| Intel Xeon with AVX‑512 | 60 | 130 | Vektoriseeritud NTT ja paralleelne relineaarimine |
| Google Edge TPU (kohandatud HE‑raamatukogu) | 38 | 110 | Eksperimentaalne, kasutab TPU‑maatriksoperatsioone polünoomide hindamiseks |

**Tootmise näpunäited**

1. **Pakendatud kodeerimine** – Krüpteeri mitu näidist korraga, kasutades CKKS‑i kuni `N/2` pesa.  
2. **Laisk reskaaleerimine** – Lükka reskaaleerimine edasi mitme korrutamise järel, et vähendada kulukaid moodulivahetusi.  
3. **FPGA‑põhine NTT kiirendaja** – Kasuta Xilinx Zynq‑i FPGA‑kiirendust äärmiselt madala energiatarbega seadmete jaoks.  

---

## 7. Turvalisuse ja Vastavuse Kontrollnimekiri

- **Võtmehaldus**: Avalik võti salvestatakse seadmes; salajane võti hoitakse turvalises enclavese või HSM‑is. Võtmeid vahetatakse iga 90 päeva tagant.  
- **Null‑teadmiste tõendid**: Genereeri lühike tõend, et sünteetiline näidis pärineb kehtivast difusiooniprotsessist, paljastamata algandmeid.  
- **Auditijälg**: Logi krüptteksti hashid (nt SHA‑256) muutumatule registrile (plokiahel), et rahuldada regulatiivseid auditeid.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Kuna toorsisulised isikuandmed ei lahku seadmest selges tekstis, täidab torujuhe “andmete‑kasutamise” kaitse nõudeid, lihtsustades andmekaitse mõjuhindamise (DPIA) protsessi.  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: Krüpteeritud PHI, mida töödeldakse HE‑ga, loetakse de‑identifitseeritud andmestikuks ekspertide määratluse alusel, eeldusel, et dekrüpteerimisvõti on rangelt kontrollitud.

---

## 8. Reaalsed Kasutusjuhtumid

1. **Nutikad Tervisekantad** – Loovad sünteetilisi südame‑sageduse mustreid mudelite treenimiseks, paljastamata patsiendi vitalseid andmeid.  
2. **Tööstus‑IoT** – Toovad sünteetilisi vibratsioonisignaale ennetava hoolduse jaoks, hoides ettevõtte masinate patenteeritud andmed krüpteerituna.  
3. **Autonoomsed Sõidukid** – Loovad sünteetilisi LIDAR‑punktipilveid äärealadel, võimaldades pidevat mudeli täiustamist ilma toorsõidukite andmeid jagamata.  

---

## 9. Tuleviku Suunad

- **Hübriidne HE‑MPC**: Kombineeri homomorfne krüpteerimine turvalise mitme‑osapoole arvutamisega, et võimaldada koostööl põhinevat sünteetilist andmete loomist mitme ääreseadme vahel.  
- **Dünaamilised Polünoomilised Võrgud**: Kasuta **Neural Architecture Search (NAS)**‑i, et automaatselt leida madala astme polünoomilised lähendused, mis tasakaalustavad täpsust ja homomorfset kulu.  
- **Kvantitöökindel HE**: Uuri lattice‑põhiseid skeeme, mis püsivad turvalised post‑kvantumirünnakute vastu, tagades pikaajalise vastavuse kriitilistele infrastruktuuridele.  

---

## Vaata Ka

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