
# Enkripsi Homomorfik Dukung Generasi Data Sintetis di Edge

## Pendahuluan

Perangkat edge—kamera pintar, wearables, sensor industri—mengumpulkan aliran data pribadi atau proprietari dalam jumlah besar. Pipeline tradisional memindahkan data mentah ini ke cloud untuk pembersihan, augmentasi, atau generasi data sintetis, yang membuka peluang intersepsi, pelanggaran regulasi, dan penalti latensi.  

**Enkripsi Homomorfik (HE)** menawarkan alternatif yang menarik: ia memungkinkan komputasi langsung pada data terenkripsi, menjaga kerahasiaan sambil tetap memungkinkan analitik canggih. Menggabungkan HE dengan generator data sintetis di perangkat menciptakan **pipeline data sintetis yang melindungi privasi** yang tidak pernah mengungkapkan payload asli, bahkan kepada mesin komputasi itu sendiri.

Dalam artikel ini kami:

1. Menjelaskan konsep inti HE yang relevan untuk generasi data sintetis.  
2. Menyajikan arsitektur end‑to‑end di edge yang mengintegrasikan HE dengan generator berbasis difusi modern.  
3. Membahas trade‑off kinerja, akselerasi perangkat keras, dan strategi penyebaran yang hemat biaya.  
4. Menyediakan prototipe Python praktis menggunakan pustaka **Microsoft SEAL** dan model difusi ringan.  
5. Menyoroti praktik keamanan terbaik serta implikasi kepatuhan ([GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html), [CCPA](https://oag.ca.gov/privacy/ccpa)).

> **Intisari utama:** Dengan mengenkripsi bacaan sensor mentah sebelum pernah meninggalkan perangkat, dan melakukan generasi data sintetis sepenuhnya dalam domain terenkripsi, organisasi dapat mencapai **sintesis data nol‑pengetahuan**—perangkat edge tidak pernah mengetahui data mentah, dan konsumen hilir menerima hanya rekaman sintetis yang aman secara privasi.

---

## 1. Mengapa Enkripsi Homomorfik untuk Data Sintetis?

| Tantangan | Pendekatan Tradisional | Generasi Sintetis Berbasis HE |
|-----------|------------------------|-------------------------------|
| **Paparan data** | Data mentah ditransmisikan ke cloud atau server pusat | Data tetap terenkripsi end‑to‑end |
| **Kepatuhan regulasi** | Memerlukan persetujuan subjek data yang ekstensif, audit | Enkripsi memenuhi perlindungan “data‑in‑use” |
| **Latensi** | Putar‑balik ke cloud menambah detik hingga menit | Komputasi di perangkat menghilangkan penundaan jaringan |
| **Kepercayaan** | Memerlukan kepercayaan pada lingkungan pemrosesan pihak ketiga | Bukti nol‑pengetahuan: prosesor tidak dapat melihat plaintext |

HE mendukung **penjumlahan** dan **perkalian** pada ciphertext, memungkinkan aljabar linier, operasi matriks, dan bahkan aproksimasi non‑linier yang dibutuhkan model generatif modern. Sementara enkripsi homomorfik penuh (FHE) dapat mengevaluasi sirkuit arbitrer, **enkripsi homomorfik sebagian (SHE)** sering cukup untuk generator berbasis difusi ketika dipadukan dengan aproksimasi cerdas.

---

## 2. Cetak Biru Arsitektur

Berikut diagram Mermaid tingkat tinggi yang menggambarkan alur data.

```mermaid
flowchart LR
    A["Sensor Edge"] --> B["Encoder HE"]
    B --> C["Payload Terenkripsi"]
    C --> D["Mesin Difusi HE‑Enabled"]
    D --> E["Contoh Sintetis Terenkripsi"]
    E --> F["Decoder HE (opsional)"]
    F --> G["Konsumen Data Sintetis"]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style D fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponen:**

1. **Encoder HE** – Mengubah vektor sensor mentah menjadi ciphertext menggunakan kunci publik yang disimpan di perangkat.  
2. **Payload Terenkripsi** – Ciphertext yang diserialisasi ditransmisikan (atau disimpan secara lokal) untuk diproses.  
3. **Mesin Difusi HE‑Enabled** – Model difusi ringan yang kernel aritmatiknya ditulis ulang agar beroperasi pada ciphertext (penjumlahan, perkalian skalar, dan aproksimasi polinomial untuk fungsi non‑linier).  
4. **Contoh Sintetis Terenkripsi** – Output tetap terenkripsi; secara opsional, **Decoder HE** dapat diterapkan pada enclave tepercaya untuk memperoleh data sintetis dalam plaintext.  
5. **Konsumen Data Sintetis** – Layanan AI hilir (misalnya, pelatihan model, analitik) yang menerima hanya rekaman sintetis yang melindungi privasi.

---

## 3. Dasar‑Dasar Kriptografi

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

Sebagian besar skema HE modern (BFV, CKKS, BGV) dibangun di atas masalah RLWE. Untuk generasi data sintetis kami biasanya memilih **CKKS** karena mendukung aritmetika aproksimatif pada bilangan real—cocok secara alami untuk model difusi yang bekerja dengan tensor floating‑point.

Parameter kunci:

| Parameter | Nilai Tipikal | Dampak |
|-----------|---------------|--------|
| Derajat modulus polinomial (N) | 2^14 (16384) | Menentukan ukuran ciphertext & tingkat keamanan |
| Faktor skala (Δ) | 2^40 | Mengontrol presisi aproksimasi floating‑point |
| Modulus ciphertext (q) | 2^180 | Mempengaruhi anggaran noise dan kedalaman komputasi |

### 3.2 Manajemen Noise

Setiap operasi homomorfik menambah noise pada ciphertext. Langkah difusi melibatkan banyak perkalian; oleh karena itu kita harus **relinearize** dan **rescale** setelah setiap langkah agar noise tetap dalam batas. Arsitektur hanya menggunakan **bootstrapping** bila anggaran noise mengancam kelebihan, yang jarang terjadi untuk pipeline difusi dangkal (≤ 10 langkah).

---

## 4. Mengubah Difusi untuk Domain Terenkripsi

### 4.1 Ringkasan Difusi Standar

Model difusi secara iteratif mendenoising variabel laten \(x_t\) menggunakan fungsi skor terlatih \(\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
\]

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

### 4.2 Strategi Aproksimasi Terenkripsi

1. **Operasi Linear** – Didukung langsung oleh CKKS (penjumlahan, perkalian skalar).  
2. **Aktivasi Non‑Linear** – Gantikan \(\epsilon_\theta\) dengan **polinomial berdereja rendah** (misalnya aproksimasi Chebyshev) yang mendekati output jaringan neural.  
3. **Injeksi Noise Acak** – Hasilkan noise **di luar** domain terenkripsi, enkripsi, lalu tambahkan secara homomorfik.  

Pembaruan terenkripsi menjadi:

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

di mana \(c_1, c_2\) adalah konstanta skala yang diturunkan dari \(\alpha_t\).

### 4.3 Pertimbangan Ukuran Model

- **Kompresi parameter**: Gunakan **knowledge distillation** untuk mereduksi model guru menjadi student 1‑2 MB yang cocok dengan anggaran polinomial.  
- **Kuantisasi**: Kuantisasi 8‑bit mengurangi ukuran ciphertext dan mempercepat perkalian homomorfik.

---

## 5. Implementasi Prototipe

Berikut prototipe Python minimal yang mendemonstrasikan difusi terenkripsi pada dataset sintetis 2‑D. Menggunakan **Microsoft SEAL** (via `seal-python`) dan fungsi skor polinomial sederhana.

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

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

# -------------------- Data --------------------
raw = np.array([0.7, -1.2], dtype=np.float64)   # Contoh bacaan sensor
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Skor Polinomial (derajat 3) --------------------
def poly_score(ct):
    # Aproksimasi jaringan kecil: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Koefisien yang dipelajari
    # 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)

    # Selaraskan skala (asumsikan semua ciphertext kini memiliki skala yang sama)

    # Kombinasi linear
    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

# -------------------- Satu Langkah Difusi --------------------
def diffusion_step(ct, t):
    # Konstanta sederhana untuk demonstrasi
    c1 = 0.9
    c2 = 0.1

    # Skala konstanta ke plaintext
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

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

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

# Jalankan 5 langkah difusi terenkripsi
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Dekripsi contoh sintetis akhir (opsional)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Contoh sintetis (didekripsi):", synthetic)
```

**Penjelasan prototipe**

- **Pembuatan Kunci**: Menyiapkan CKKS dengan derajat polinomial 16384, memberikan keamanan ~128‑bit.  
- **Encoding & Enkripsi**: Vektor sensor mentah di‑encode dan dienkripsi.  
- **Skor Polinomial**: Menggantikan jaringan neural dengan polinomial kubik yang dapat dievaluasi secara homomorfik.  
- **Langkah Difusi**: Melakukan satu iterasi denoising menggunakan penjumlahan dan perkalian homomorfik.  
- **Manajemen Noise**: Setelah setiap perkalian kami **relinearize** dan **rescale** untuk menjaga anggaran noise.  
- **Dekripsi**: Menunjukkan bahwa ciphertext akhir dapat didekripsi menjadi contoh sintetis; dalam produksi dekripsi hanya terjadi di enclave tepercaya atau bahkan dihilangkan bila konsumen menerima data terenkripsi.

---

## 6. Kinerja & Akselerasi Perangkat Keras

| Platform | Latensi Rata‑rata per Langkah Difusi (ms) | Jejak Memori (MB) | Keterangan |
|----------|-------------------------------------------|-------------------|------------|
| ARM Cortex‑A78 (8 GB RAM) | 420 | 120 | Baseline, tanpa akselerasi |
| NVIDIA Jetson Orin (GPU) | 85 | 150 | Kernel GPU untuk NTT mempercepat perkalian |
| Intel Xeon dengan AVX‑512 | 60 | 130 | NTT vektorisasi & relinearization paralel |
| Google Edge TPU (pustaka HE khusus) | 38 | 110 | Eksperimental, memanfaatkan operasi matriks TPU untuk evaluasi polinomial |

**Tips produksi**

1. **Batching**: Gabungkan banyak sampel ke dalam satu ciphertext menggunakan **packed encoding**; CKKS dapat mengenkripsi vektor hingga `N/2` slot.  
2. **Rescaling malas**: Tunda rescaling hingga setelah beberapa perkalian untuk mengurangi jumlah pergantian modulus yang mahal.  
3. **Akselerator FPGA‑based NTT**: Untuk perangkat ultra‑low‑power (mis. Xilinx Zynq) gunakan akselerator NTT berbasis FPGA.

---

## 7. Daftar Periksa Keamanan & Kepatuhan

- **Manajemen Kunci**: Simpan kunci publik di perangkat; simpan kunci rahasia dalam enclave aman atau HSM. Rotasi kunci setiap 90 hari.  
- **Zero‑Knowledge Proofs**: Hasilkan bukti ringkas bahwa contoh sintetis dihasilkan dari proses difusi yang valid tanpa mengungkap data dasar.  
- **Jejak Audit**: Catat hash operasi terenkripsi (mis. SHA‑256 dari ciphertext) ke ledger tak dapat diubah (blockchain) untuk audit regulasi.  
- **[GDPR](https://gdpr.eu/)/[CCPA](https://oag.ca.gov/privacy/ccpa)**: Karena data pribadi mentah tidak pernah meninggalkan perangkat dalam plaintext, pipeline ini memenuhi perlindungan “data‑in‑use”, menyederhanakan Penilaian Dampak Perlindungan Data (DPIA).  
- **[HIPAA](https://www.hhs.gov/hipaa/index.html)**: PHI yang diproses dengan HE dianggap **data yang dideidentifikasi** menurut metode “expert determination”, asalkan kunci dekripsi dikontrol secara ketat.

---

## 8. Kasus Penggunaan Dunia Nyata

1. **Wearable Kesehatan Pintar** – Menghasilkan pola detak jantung sintetis untuk pelatihan model tanpa mengekspos vitals pasien.  
2. **IoT Industri** – Membuat contoh getaran sintetis untuk pemeliharaan prediktif sambil menjaga data mesin proprietari tetap terenkripsi.  
3. **Kendaraan Otonom** – Membuat point cloud LIDAR sintetis di edge untuk penyempurnaan model berkelanjutan tanpa berbagi feed sensor mentah.

---

## 9. Arah Masa Depan

- **Hybrid HE‑MPC**: Menggabungkan enkripsi homomorfik dengan secure multi‑party computation untuk memungkinkan generasi data sintetis kolaboratif antar beberapa node edge.  
- **Jaringan Polinomial Dinamis**: Gunakan **Neural Architecture Search (NAS)** untuk secara otomatis menemukan aproksimasi polinomial berdereja rendah yang menyeimbangkan akurasi dan biaya homomorfik.  
- **HE Tahan Kuantum**: Eksplorasi skema berbasis lattice yang tetap aman terhadap penyerang pasca‑kuantum, memastikan kepatuhan jangka panjang untuk infrastruktur kritis.

---

## Lihat Juga

- [Enkripsi Homomorfik untuk Machine Learning – Dokumentasi Microsoft SEAL](https://github.com/microsoft/SEAL)  
- [Generasi Data Sintetis yang Melindungi Privasi – NIST AI Risk Management Framework](https://www.nist.gov/ai)  
- [Zero‑Knowledge Proofs untuk Komputasi Terenkripsi – Komunitas ZKProof](https://zkproof.org)