
# Homomorf kryptering möjliggör syntetisk datagenerering på kanten

## Introduktion

Kant‑enheter—smarta kameror, wearables, industriella sensorer—samlar in massiva strömmar av personlig eller proprietär data. Traditionella pipelines flyttar dessa rådata till molnet för rensning, augmentation eller syntetisk datagenerering, vilket exponerar dem för avlyssning, regulatoriska brott och latenspenaltyer.  

**Homomorf kryptering (HE)** erbjuder ett övertygande alternativ: den tillåter beräkning direkt på krypterad data, bevarar konfidentialitet samtidigt som den möjliggör avancerad analys. Att kombinera HE med på‑enhetssyntetiska datageneratorer skapar en **integritetsskyddad syntetisk datapipeline** som aldrig avslöjar den ursprungliga nyttolasten, inte ens för beräkningsmotorn själv.

I den här artikeln gör vi:

1. Förklarar de grundläggande koncepten i HE som är relevanta för syntetisk datagenerering.  
2. Skisserar en end‑to‑end‑arkitektur för kanten som integrerar HE med moderna diffusions‑baserade generatorer.  
3. Diskuterar prestanda‑trade‑offs, hårdvaruacceleration och kostnadseffektiva deploymentsstrategier.  
4. Tillhandahåller ett praktiskt Python‑prototyp med **Microsoft SEAL**‑biblioteket och en lättviktig diffusionsmodell.  
5. Belyser säkerhets‑bästa praxis och efterlevnadsimplikationer ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Viktig insikt:** Genom att kryptera råa sensormätningar innan de någonsin lämnar enheten, och utföra den syntetiska datagenereringen helt i den krypterade domänen, kan organisationer uppnå **zero‑knowledge data synthesis**—kant‑enheten lär sig aldrig de råa data, och nedströms konsumenter får endast syntetiska, integritetssäkra poster.

---

## 1. Varför homomorf kryptering för syntetisk data?

| Utmaning | Traditionellt tillvägagångssätt | HE‑aktiverad syntetisk generering |
|----------|----------------------------------|-----------------------------------|
| **Dataexponering** | Rådata överförs till moln eller central server | Data förblir krypterad end‑to‑end |
| **Regulatorisk efterlevnad** | Kräver omfattande samtycke från datainnehavare, revisioner | Kryptering uppfyller skydd för “data‑in‑use” |
| **Latens** | Rundresa till molnet lägger till sekunder till minuter | Beräkning på enheten eliminerar nätverksfördröjning |
| **Förtroende** | Kräver förtroende för tredjeparts‑bearbetningsmiljö | Zero‑knowledge‑bevis: processorn kan inte se klartext |

HE stödjer **addition** och **multiplikation** på chiffertexter, vilket möjliggör linjär algebra, matrisoperationer och även icke‑linjära approximationer som krävs av moderna generativa modeller. Medan full homomorfisk kryptering (FHE) kan evaluera godtyckliga kretsar, räcker **något homomorfisk kryptering (SHE)** ofta för diffusions‑baserade generatorer när den kombineras med smarta approximationer.

---

## 2. Arkitekturell ritning

Nedan är ett hög‑nivå‑Mermaid‑diagram som illustrerar dataflödet.

```mermaid
flowchart LR
    A["Kant‑sensor"] --> B["HE‑kodare"]
    B --> C["Krypterad nyttolast"]
    C --> D["HE‑aktiverad diffusionsmotor"]
    D --> E["Krypterat syntetiskt prov"]
    E --> F["HE‑avkodare (valfri)"]
    F --> G["Syntetisk datakonsument"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponenter:**

1. **HE‑kodare** – Omvandlar råa sensorvektorer till chiffertexter med en publik nyckel som lagras på enheten.  
2. **Krypterad nyttolast** – Serialiserad chiffertext som överförs (eller behålls lokalt) för bearbetning.  
3. **HE‑aktiverad diffusionsmotor** – En lättviktig diffusionsmodell vars aritmetiska kärnor har skrivits om för att fungera på chiffertexter (addition, skalär multiplikation och polynomapproximationer för icke‑linjära funktioner).  
4. **Krypterat syntetiskt prov** – Utdata förblir krypterad; valfritt kan en **HE‑avkodare** appliceras i en betrodd enclave för att erhålla klartextsyntetisk data.  
5. **Syntetisk datakonsument** – Nedströms AI‑tjänster (t.ex. modellträning, analys) som endast får syntetiska, integritetsskyddade poster.

---

## 3. Kryptografiska grunder

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

De flesta moderna HE‑scheman (BFV, CKKS, BGV) bygger på RLWE‑problemet. För syntetisk datagenerering väljer vi vanligtvis **CKKS** eftersom den stödjer approximativ aritmetik på reella tal – en naturlig match för diffusionsmodeller som arbetar med flyttalstensorer.

**Nyckelparametrar**

| Parameter | Typiskt värde | Påverkan |
|-----------|---------------|----------|
| Polynommodulgrad (N) | 2^14 (16384) | Bestämmer chifferstorlek & säkerhetsnivå |
| Skalningsfaktor (Δ) | 2^40 | Kontrollerar precisionen i flyttalsapproximationen |
| Chiffermodul (q) | 2^180 | Påverkar brusbudget och beräkningsdjup |

### 3.2 Brus‑hantering

Varje homomorf operation adderar brus till chiffertexten. Diffusionssteg innebär många multiplikationer; därför måste vi **relinarisera** och **reskala** efter varje steg för att hålla bruset inom gränserna. Bootstrapping används endast när brusbudgeten hotar att överskridas, vilket är sällsynt för grunda diffusions‑pipelines (≤ 10 steg).

---

## 4. Om‑design av diffusion för den krypterade domänen

### 4.1 Standard diffusion – en snabb återblick

En diffusionsmodell avlägsnar iterativt brus från en latent variabel \(x_t\) med en inlärd score‑funktion \(\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
\]

där \(z \sim \mathcal{N}(0, I)\).

### 4.2 Krypterad approximationsstrategi

1. **Linjära operationer** – Direkt stöd av CKKS (addition, skalär multiplikation).  
2. **Icke‑linjära aktiveringar** – Ersätt \(\epsilon_\theta\) med ett **lågt‑gradigt polynom** (t.ex. Chebyshev‑approximation) som efterliknar nätverkets output.  
3. **Slumpmässigt brus** – Generera brus **utanför** den krypterade domänen, kryptera det och addera homomorfiskt.  

Den krypterade uppdateringen blir då:

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

där \(c_1, c_2\) är skalningskonstanter härledda från \(\alpha_t\).

### 4.3 Modellstorlek

- **Parameterkomprimering**: Använd **knowledge distillation** för att krympa en lärarmodell till en 1‑2 MB‑student som passar polynombudgeten.  
- **Kvantisering**: 8‑bits kvantisering minskar chifferstorlek och snabbar upp homomorf multiplikation.

---

## 5. Prototyp‑implementation

Koden nedan visar ett minimalt Python‑exempel som demonstrerar krypterad diffusion på ett syntetiskt 2‑D‑dataset. Den använder **Microsoft SEAL** (via `seal-python`) och en enkel polynom‑score‑funktion.

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

# -------------------- HE‑inställning --------------------
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)   # Exempel på sensoravläsning
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynom‑score (grad 3) --------------------
def poly_score(ct):
    # Approximerar ett litet neuralt nätverk: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Exempel på inlärda koefficienter
    # 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)

    # Kombinera linjärt
    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

# -------------------- Ett diffusionssteg --------------------
def diffusion_step(ct, t):
    # Förenklade konstanter för demonstration
    c1 = 0.9
    c2 = 0.1

    # Skala konstanterna till plaintexts
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

    # Beräkna score
    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)

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

# Kör 5 krypterade diffusionssteg
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Avkoda slutligt syntetiskt prov (valfritt)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Syntetiskt (avkodat) prov:", synthetic)
```

**Förklaring av prototypen**

- **Nyckelgenerering**: Sätter upp CKKS med en polynommodulgrad på 16384, vilket ger ~128‑bits säkerhet.  
- **Kodning & kryptering**: Rå sensorvektor kodas och krypteras.  
- **Polynom‑score**: Ersätter det neurala nätverket med ett kubiskt polynom som kan evalueras homomorft.  
- **Diffusionssteg**: Utför en förenklad denoising‑iteration med homomorf addition och multiplikation.  
- **Brus‑hantering**: Efter varje multiplikation **relinarisera** och **reskala** för att hålla brusbudgeten i schack.  
- **Avkryptering**: Visar att den slutliga chiffertexten kan avkrypteras till ett syntetiskt prov; i produktion sker avkryptering endast i en betrodd enclave eller uteblir helt om konsumenten accepterar krypterad data.

---

## 6. Prestanda & hårdvaruacceleration

| Plattform | Genomsnittlig latens per diffusionssteg (ms) | Minnesanvändning (MB) | Kommentar |
|-----------|----------------------------------------------|-----------------------|-----------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Baslinje, ingen acceleration |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | GPU‑kernlar för NTT påskyndar multiplikation |
| Intel Xeon med AVX‑512 | 60 | 130 | Vektoriserad NTT och parallell relinearisation |
| Google Edge TPU (specialiserat HE‑bibliotek) | 38 | 110 | Experimentellt, utnyttjar TPU‑matrisoperationer för polynom‑evalueringar |

**Tips för produktion**

1. **Batcha flera prover** i en enda chiffertext med **paketerad kodning**; CKKS kan kryptera vektorer med upp till `N/2` slots.  
2. **Lat rescaling**: skjuta upp rescaling tills efter några multiplikationer för att minska antalet kostsamma modulus‑byten.  
3. **Utnyttja FPGA‑baserade NTT‑acceleratorer** för ultra‑lågeffekt‑kant‑enheter (t.ex. Xilinx Zynq).

---

## 7. Säkerhets‑ & efterlevnadskontrollista

- **Nyckelhantering**: Förvara publika nycklar på enheten; håll hemliga nycklar i en säker enclave eller HSM. Rotera nycklar var 90:e dag.  
- **Zero‑knowledge‑bevis**: Generera ett kort bevis på att det syntetiska provet härstammar från en giltig diffusionsprocess utan att avslöja underliggande data.  
- **Audit‑logg**: Logga hashar av krypterade operationer (t.ex. SHA‑256 av chiffertext) till en oföränderlig ledger (blockchain) för regulatoriska revisioner.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Eftersom rå personlig data aldrig lämnar enheten i klartext, uppfyller pipelinen “data‑in‑use”‑skydd, vilket förenklar DPIA‑processen.  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: Krypterad PHI som bearbetas under HE betraktas som **de‑identifierad** data enligt “expert‑determination”-metoden, förutsatt att dekrypteringsnyckeln är strikt kontrollerad.

---

## 8. Verkliga användningsfall

1. **Smarta sjukvårds‑wearables** – Generera syntetiska hjärtfrekvensmönster för modellträning utan att exponera patientens vitala tecken.  
2. **Industriell IoT** – Skapa syntetiska vibrationssignaturer för prediktivt underhåll samtidigt som proprietär maskindata hålls krypterad.  
3. **Autonoma fordon** – Producera syntetiska LIDAR‑punktmoln på kanten för kontinuerlig modellförfining utan att dela råa sensordata.

---

## 9. Framtida riktningar

- **Hybrid HE‑MPC**: Kombinera homomorf kryptering med Secure Multi‑Party Computation för att möjliggöra samarbets‑syntetisk datagenerering över flera kant‑noder.  
- **Dynamiska polynom‑nätverk**: Använd **Neural Architecture Search (NAS)** för automatiskt att upptäcka lågt‑gradiga polynomapproximationer som balanserar noggrannhet och homomorf kostnad.  
- **Kvant‑resistent HE**: Utforska gitter‑baserade scheman som förblir säkra mot post‑kvant‑adversärer, vilket säkerställer långsiktig efterlevnad för kritisk infrastruktur.

---

## Se även

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