
# Generowanie Syntetycznych Danych z Wykorzystaniem Szyfrowania Homomorficznego na Krawędzi

## Wprowadzenie

Urządzenia brzegowe — inteligentne kamery, wearables, czujniki przemysłowe — zbierają ogromne strumienie danych osobistych lub własnościowych. Tradycyjne potoki przenoszą te surowe dane do chmury w celu czyszczenia, augmentacji lub generowania danych syntetycznych, narażając je na przechwycenie, naruszenia regulacyjne i opóźnienia.  

**Szyfrowanie homomorficzne (HE)** oferuje atrakcyjną alternatywę: pozwala na wykonywanie obliczeń bezpośrednio na zaszyfrowanych danych, zachowując poufność, a jednocześnie umożliwiając zaawansowaną analizę. Połączenie HE z generatorami danych syntetycznych działającymi na urządzeniu tworzy **prywatny potok generowania danych syntetycznych**, który nigdy nie ujawnia oryginalnego ładunku, nawet samemu silnikowi obliczeniowemu.

W tym artykule:

1. Wyjaśniamy podstawowe pojęcia HE istotne dla generowania danych syntetycznych.  
2. Przedstawiamy kompletną architekturę brzegową integrującą HE z nowoczesnymi generatorami opartymi na dyfuzji.  
3. Omawiamy kompromisy wydajności, przyspieszenie sprzętowe i strategie wdrażania przy niskich kosztach.  
4. Dostarczamy praktyczny prototyp w Pythonie wykorzystujący bibliotekę **Microsoft SEAL** oraz lekki model dyfuzyjny.  
5. Wyróżniamy najlepsze praktyki bezpieczeństwa oraz implikacje zgodności ([RODO](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Kluczowa lekcja:** Szyfrując surowe odczyty czujników zanim opuścią urządzenie i wykonując generowanie danych syntetycznych w pełni w domenie zaszyfrowanej, organizacje mogą osiągnąć **syntezę danych zerowej wiedzy** — urządzenie brzegowe nigdy nie poznaje surowych danych, a odbiorcy końcowi otrzymują jedynie syntetyczne, bezpieczne rekordy.

---

## 1. Dlaczego szyfrowanie homomorficzne dla danych syntetycznych?

| Wyzwanie | Tradycyjne podejście | Generowanie syntetyczne z HE |
|----------|----------------------|------------------------------|
| **Ujawnienie danych** | Surowe dane przesyłane do chmury lub serwera centralnego | Dane pozostają zaszyfrowane end‑to‑end |
| **Zgodność regulacyjna** | Wymaga rozbudowanej zgody podmiotów danych, audytów | Szyfrowanie spełnia ochronę „danych w użyciu” |
| **Opóźnienie** | Runda‑trip do chmury dodaje sekundy‑minuty | Obliczenia na urządzeniu eliminują opóźnienia sieciowe |
| **Zaufanie** | Wymaga zaufania do środowiska przetwarzającego stronę trzecią | Dowód zerowej wiedzy: procesor nie widzi tekstu jawnego |

HE obsługuje **dodawanie** i **mnożenie** na szyfrogramach, co umożliwia algebrę liniową, operacje macierzowe oraz przybliżenia nieliniowe niezbędne nowoczesnym modelom generatywnym. Choć pełne szyfrowanie homomorficzne (FHE) może ocenić dowolny obwód, **nieco homomorficzne szyfrowanie (SHE)** często wystarcza dla generatorów opartych na dyfuzji przy zastosowaniu sprytnych przybliżeń.

---

## 2. Projekt architektoniczny

Poniżej znajduje się diagram Mermaid wysokiego poziomu ilustrujący przepływ danych.

```mermaid
flowchart LR
    A["Czujnik brzegowy"] --> B["Koder HE"]
    B --> C["Zaszyfrowane ładunki"]
    C --> D["Silnik dyfuzji z HE"]
    D --> E["Zaszyfrowana próbka syntetyczna"]
    E --> F["Dekoder HE (opcjonalny)"]
    F --> G["Konsument danych syntetycznych"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponenty:**

1. **Koder HE** – konwertuje wektory surowych pomiarów na szyfrogramy przy użyciu klucza publicznego przechowywanego w urządzeniu.  
2. **Zaszyfrowany ładunek** – zserializowany szyfrogram, który może być przesyłany (lub pozostawiony lokalnie) do przetwarzania.  
3. **Silnik dyfuzji z HE** – lekki model dyfuzyjny, którego jądra arytmetyczne zostały przepisane tak, aby działały na szyfrogramach (dodawanie, mnożenie skalarne oraz przybliżenia wielomianowe dla funkcji nieliniowych).  
4. **Zaszyfrowana próbka syntetyczna** – wyjście pozostaje zaszyfrowane; opcjonalnie **Dekoder HE** może zostać zastosowany w zaufanym enclave, aby uzyskać jawny syntetyczny rekord.  
5. **Konsument danych syntetycznych** – downstreamowe usługi AI (np. trening modeli, analityka), które otrzymują wyłącznie syntetyczne, prywatne rekordy.

---

## 3. Fundamenty kryptograficzne

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

Większość współczesnych schematów HE (BFV, CKKS, BGV) opiera się na problemie RLWE. Do generowania danych syntetycznych najczęściej wybieramy **CKKS**, ponieważ obsługuje przybliżoną arytmetykę na liczbach rzeczywistych — naturalnie pasuje do modeli dyfuzyjnych operujących na tensorach zmiennoprzecinkowych.

Kluczowe parametry:

| Parametr | Typowa wartość | Wpływ |
|----------|----------------|-------|
| Stopień wielomianu (N) | 2^14 (16384) | Określa rozmiar szyfrogramu i poziom bezpieczeństwa |
| Współczynnik skalowania (Δ) | 2^40 | Kontroluje precyzję przybliżenia zmiennoprzecinkowego |
| Moduł szyfrogramu (q) | 2^180 | Wpływa na budżet szumu i głębokość obliczeń |

### 3.2 Zarządzanie szumem

Każda operacja homomorficzna zwiększa szum w szyfrogramie. Krok dyfuzji wymaga wielu mnożeń; dlatego musimy **relinearizować** i **przeskalować** po każdym kroku, aby szum nie przekroczył dopuszczalnego limitu. Bootstrapping stosujemy jedynie wtedy, gdy budżet szumu grozi przepełnieniem — co jest rzadkie w płytkich potokach dyfuzyjnych (≤ 10 kroków).

---

## 4. Przebudowa dyfuzji dla domeny zaszyfrowanej

### 4.1 Krótkie przypomnienie klasycznej dyfuzji

Model dyfuzyjny iteracyjnie odszumia zmienną latentną \(x_t\) przy użyciu wyuczonej funkcji wyniku \(\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
\]

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

### 4.2 Strategia przybliżenia w szyfrogramie

1. **Operacje liniowe** – bezpośrednio wspierane przez CKKS (dodawanie, mnożenie skalarne).  
2. **Aktywacje nieliniowe** – zastępujemy **niskiego stopnia wielomianem** (np. przybliżenie Czebyszewa) aproksymującym wyjście sieci neuronowej.  
3. **Wstrzykiwanie szumu** – generujemy szum poza domeną zaszyfrowaną, szyfrujemy go i dodajemy homomorficznie.  

Zaktualizowane równanie w szyfrogramie:

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

gdzie \(c_1, c_2\) to stałe pochodzące z \(\alpha_t\).

### 4.3 Rozważania dotyczące rozmiaru modelu

- **Kompresja parametrów**: używamy **knowledge distillation**, aby skompresować model nauczyciela do ucznia o rozmiarze 1‑2 MB, spełniającego budżet wielomianowy.  
- **Kwantyzacja**: kwantyzacja do 8 bitów zmniejsza rozmiar szyfrogramu i przyspiesza mnożenie homomorficzne.

---

## 5. Implementacja prototypowa

Poniżej znajduje się minimalny prototyp w Pythonie, demonstrujący szyfrowaną dyfuzję na syntetycznym zbiorze 2‑D. Wykorzystuje **Microsoft SEAL** (poprzez `seal‑python`) oraz prostą funkcję wielomianową jako przybliżenie sieci.

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

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

# -------------------- Dane wejściowe --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Przykładowy odczyt czujnika
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Wielomianowe przybliżenie wyniku --------------------
def poly_score(ct):
    # Przybliżenie małej sieci: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Przykładowe wyuczone współczynniki

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

    # Łączenie liniowe (zakładamy, że skale są już wyrównane)
    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

# -------------------- Jeden krok dyfuzji --------------------
def diffusion_step(ct, t):
    # Uproszczone stałe demonstracyjne
    c1 = 0.9
    c2 = 0.1

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

    # Obliczanie przybliżonego wyniku
    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)

    # Połączenie
    evaluator.add(term1, term2, term1)
    return term1

# Wykonaj 5 zaszyfrowanych kroków dyfuzji
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Opcjonalne odszyfrowanie końcowej próbki syntetycznej
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Syntetyczna (odszyfrowana) próbka:", synthetic)
```

**Krótka charakterystyka prototypu**

- **Generowanie kluczy**: Konfigurujemy CKKS z stopniem wielomianu 16384, co zapewnia ~128‑bitowe bezpieczeństwo.  
- **Kodowanie i szyfrowanie**: Surowy wektor czujnika jest kodowany i szyfrowany.  
- **Wielomianowy wynik**: Zastępujemy sieć neuronową wielomianem stopnia trzeciego, który można ocenić homomorficznie.  
- **Krok dyfuzji**: Wykonujemy jedną iterację odszumiania przy użyciu operacji homomorficznych (dodawanie, mnożenie).  
- **Zarządzanie szumem**: Po każdej mnożeniu stosujemy **relinearizację** i **przeskalowanie**, aby utrzymać budżet szumu w granicach.  
- **Odszyfrowanie**: Pokazujemy, że końcowy szyfrogram może zostać odszyfrowany do syntetycznej próbki; w produkcji odszyfrowanie odbywa się wyłącznie w zaufanym enclave lub wcale nie jest wymagane, jeśli downstream przyjmuje dane zaszyfrowane.

---

## 6. Wydajność i przyspieszenie sprzętowe

| Platforma | Średnie opóźnienie na krok dyfuzji (ms) | Zużycie pamięci (MB) | Uwagi |
|-----------|----------------------------------------|----------------------|-------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Podstawowa, bez przyspieszenia |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | Kernale GPU przyspieszają NTT, przyspieszając mnożenia |
| Intel Xeon z AVX‑512 | 60 | 130 | Wektorowy NTT i równoległa relinearizacja |
| Google Edge TPU (niestandardowa biblioteka HE) | 38 | 110 | Eksperymentalne, wykorzystuje macierzowe operacje TPU do przybliżeń wielomianowych |

**Wskazówki produkcyjne**

1. **Pakowanie wielu próbek** w jeden szyfrogram przy użyciu **kodowania pakietowego**; CKKS pozwala zaszyfrować wektory o długości do `N/2` slotów.  
2. **Leniwa reskalacja**: odkładaj przeskalowanie po kilku mnożeniach, aby ograniczyć liczbę kosztownych przełączeń modułów.  
3. **Akceleratory FPGA‑based NTT**: idealne dla ultra‑niskiego poboru mocy na urządzeniach brzegowych (np. Xilinx Zynq).  

---

## 7. Lista kontrolna bezpieczeństwa i zgodności

- **Zarządzanie kluczami**: Publiczne klucze przechowuj na urządzeniu; klucze prywatne zabezpiecz w enclave lub HSM. Rotuj klucze co 90 dni.  
- **Dowody zerowej wiedzy**: Generuj zwięzły dowód, że syntetyczna próbka została wyprodukowana zgodnie z prawidłowym procesem dyfuzji, nie ujawniając danych źródłowych.  
- **Ścieżka audytu**: Loguj hasze operacji zaszyfrowanych (np. SHA‑256 szyfrogramu) w niezmiennym rejestrze (blockchain) w celu audytów regulacyjnych.  
- **RODO / CCPA**: Ponieważ surowe dane osobowe nigdy nie opuszczają urządzenia w postaci jawnej, potok spełnia wymóg ochrony „danych w użyciu”, upraszczając ocenę skutków ochrony danych (DPIA).  
- **HIPAA**: Zaszyfrowane PHI przetwarzane w HE może być uznane za **zde‑identyfikowane** dane według metody „eksperckiej oceny”, pod warunkiem ścisłej kontroli klucza deszyfrującego.

---

## 8. Przykłady zastosowań w rzeczywistym świecie

1. **Inteligentne wearables medyczne** – generowanie syntetycznych wzorców tętna do treningu modeli, bez ujawniania rzeczywistych parametrów pacjenta.  
2. **Przemysłowy IoT** – tworzenie syntetycznych sygnałów drgań dla predykcyjnego utrzymania, zachowując własność danych maszyn.  
3. **Pojazdy autonomiczne** – generowanie syntetycznych chmur punktów LIDAR na krawędzi w celu ciągłego doskonalenia modeli, bez udostępniania surowych danych czujników.  

---

## 9. Kierunki rozwoju

- **Hybrydowy HE‑MPC**: połączenie szyfrowania homomorficznego z bezpiecznym wielostronnym obliczaniem, aby umożliwić współpracujące generowanie danych syntetycznych pomiędzy wieloma węzłami brzegowymi.  
- **Dynamiczne sieci wielomianowe**: wykorzystanie **Neural Architecture Search (NAS)** do automatycznego odkrywania wielomianowych przybliżeń o niskim stopniu, które optymalizują dokładność vs. koszt homomorficzny.  
- **Szyfrowanie odporne na kwantowy atak**: badanie schematów opartych na kratowych problemach, które pozostają bezpieczne wobec przyszłych komputerów kwantowych, zapewniając długoterminową zgodność dla infrastruktury krytycznej.

---

## Zobacz także

- [Szyfrowanie homomorficzne dla uczenia maszynowego – dokumentacja Microsoft SEAL](https://github.com/microsoft/SEAL)  
- [Prywatne generowanie danych syntetycznych – Ramowy System Zarządzania Ryzykiem AI NIST](https://www.nist.gov/ai)  
- [Dowody zerowej wiedzy dla obliczeń zaszyfrowanych – społeczność ZKProof](https://zkproof.org)