1. Hjem
  2. Blog
  3. HE Syntetisk Data Kant

Homomorfisk kryptering drevet syntetisk data‑generering på kanten

Homomorfisk kryptering drevet syntetisk data‑generering på kanten

Introduktion

Edge‑enheder—smarte kameraer, wearables, industrielle sensorer—indsamler massive strømme af personlige eller proprietære data. Traditionelle pipelines flytter disse rå data til skyen for rengøring, augmentation eller syntetisk data‑generering, hvilket udsætter dem for aflytning, regulatoriske overtrædelser og latenstidsstraffe.

Homomorfisk kryptering (HE) tilbyder et overbevisende alternativ: den tillader beregning direkte på krypterede data, bevarer fortrolighed samtidig med at den muliggør avanceret analyse. At kombinere HE med syntetiske data‑generatorer på enheden skaber en privatlivsbevarende syntetisk data‑pipeline, der aldrig afslører den oprindelige payload, selv for beregningsmotoren selv.

I denne artikel gør vi:

  1. Forklar de grundlæggende koncepter for HE, der er relevante for syntetisk data‑generering.
  2. Skitsér en ende‑til‑ende edge‑arkitektur, der integrerer HE med moderne diffusion‑baserede generatorer.
  3. Diskuter præstationsafvejninger, hardwareacceleration og omkostningseffektive deploymentsstrategier.
  4. Giv en praktisk Python‑prototype ved brug af Microsoft SEAL‑biblioteket og en letvægts diffusion‑model.
  5. Fremhæv sikkerheds‑best practices og overholdelsesimplikationer (GDPR, HIPAA, CCPA).

Vigtig pointe: Ved at kryptere rå sensoraflæsninger, før de nogensinde forlader enheden, og udføre den syntetiske data‑generering fuldstændigt i den krypterede domæne, kan organisationer opnå zero‑knowledge data‑syntese—edge‑enheden lærer aldrig de rå data, og efterfølgende forbrugere modtager kun syntetiske, privatliv‑sikre poster.


1. Hvorfor homomorfisk kryptering til syntetisk data?

UdfordringTraditionel tilgangHE‑aktiveret syntetisk generering
DataeksponeringRå data transmitteres til skyen eller central serverData forbliver krypteret ende‑til‑ende
Regulatorisk overholdelseKræver omfattende samtykke fra datasubjekter, revisionerKryptering opfylder “data‑in‑use” beskyttelse
LatenstidRundrejse til skyen tilføjer sekunder til minutterBeregning på enheden eliminerer netværksforsinkelse
TillidKræver tillid til tredjeparts behandlingsmiljøZero‑knowledge bevis: processor kan ikke se klartekst

2. Arkitektonisk skitse

Nedenfor er et overordnet Mermaid‑diagram, der illustrerer dataflowet.

  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

Komponenter:

  1. HE‑koder – Konverterer rå sensor‑vektorer til ciphertext ved brug af en offentlig nøgle, der er gemt på enheden.
  2. Krypteret payload – Serialiseret ciphertext, der transmitteres (eller opbevares lokalt) til behandling.
  3. HE‑aktiveret diffusion‑motor – En letvægts diffusion‑model, hvis aritmetiske kerner er omskrevet til at operere på ciphertexts (addition, skalarmultiplikation og polynomiale tilnærmelser for ikke‑lineære funktioner).
  4. Krypteret syntetisk prøve – Outputtet forbliver krypteret; valgfrit kan en HE‑dekoder anvendes i en betroet enclave for at opnå klartekst syntetisk data.
  5. Syntetisk data‑forbruger – Nedstrøms AI‑tjenester (fx modeltræning, analyse), der kun modtager syntetiske, privatlivsbevarende poster.

3. Kryptografiske grundlag

3.1 Ring‑Learning With Errors (RLWE)

De fleste moderne HE‑skemaer (BFV, CKKS, BGV) er bygget på RLWE‑problemet. Til syntetisk data‑generering vælger vi typisk CKKS, fordi den understøtter tilnærmet aritmetik på reelle tal—en naturlig pasform for diffusion‑modeller, der arbejder med flydende‑punkt‑tensorer.

Nøgleparametre:

ParameterTypisk værdiIndvirkning
Polynomium modulus grad (N)2^14 (16384)Bestemmer ciphertext‑størrelse og sikkerhedsniveau
Skaleringsfaktor (Δ)2^40Styrer præcisionen af flydende‑punkt‑tilnærmelsen
Ciphertext‑modulus (q)2^180Påvirker støjbudget og beregningsdybde

3.2 Støj‑håndtering

Hver homomorf operation tilføjer støj til ciphertexten. Diffusions‑trinene involverer mange multiplikationer; derfor skal vi relinearizere og reskalere efter hvert trin for at holde støjen inden for grænserne. Arkitekturen bruger bootstrapping kun når støjbudgettet truer at løbe ud, hvilket er sjældent for lave‑dybde diffusion‑pipelines (≤ 10 trin).


4. Om‑design af diffusion for den krypterede domæne

4.1 Standard diffusion opsummering

En diffusion‑model denoiser iterativt en latent variabel (x_t) ved hjælp af en lært 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 ]

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

4.2 Krypteret tilnærmningsstrategi

  1. Lineære operationer – Direkte understøttet af CKKS (addition, skalarmultiplikation).
  2. Ikke‑lineær aktivering – Erstat (\epsilon_\theta) med et lav‑gradspolynomium (fx Chebyshev‑tilnærmelse), der tilnærmer netværkets output.
  3. Tilfældig støj‑injektion – Generer støj uden for den krypterede domæne, krypter den, og tilføj homomorft.

Den resulterende krypterede opdatering bliver:

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

hvor (c_1, c_2) er skaleringskonstanter afledt af (\alpha_t).

4.3 Modelstørrelses‑overvejelser

  • Parameterkomprimering: Brug knowledge distillation til at krympe lærer‑modellen til en 1‑2 MB elev, der passer inden for polynomium‑omkostningsbudgettet.
  • Kvantisering: 8‑bit kvantisering reducerer ciphertext‑størrelse og accelererer homomorf multiplikation.

5. Prototype‑implementering

Nedenfor er en minimal Python‑prototype, der demonstrerer krypteret diffusion på et syntetisk 2‑D datasæt. Den bruger Microsoft SEAL (via seal-python) og en simpel polynomiel score‑funktion.

# python
import seal
import numpy as np

# -------------------- HE Opsætning --------------------
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)   # Eksempel på sensoraflæsning
plain = encoder.encode(raw, scale)
cipher = seal.Ciphertext()
encryptor.encrypt(plain, cipher)

# -------------------- Polynomiel Score (grad 3) --------------------
def poly_score(ct):
    # Tilnærmer et lille neuralt net: a0 + a1*x + a2*x^2 + a3*x^3
    coeffs = [0.1, 0.5, -0.2, 0.05]  # Eksempel‑lærte 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)

    # Alignér skalaer (antager at alle ciphertexts nu deler samme skala efter rescaling)

    # Lineær kombination
    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

# -------------------- Ét Diffusionstrin --------------------
def diffusion_step(ct, t):
    # Forenklede konstanter til demonstration
    c1 = 0.9
    c2 = 0.1

    # Skaler konstanter til plaintexts
    pt_c1 = encoder.encode(c1, scale)
    pt_c2 = encoder.encode(c2, scale)

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

    # Kombinér
    evaluator.add(term1, term2, term1)
    return term1

# Kør 5 krypterede diffusionstrin
ct = cipher
for step in range(5):
    ct = diffusion_step(ct, step)

# Dekrypter endelig syntetisk prøve (valgfrit)
plain_out = seal.Plaintext()
decryptor.decrypt(ct, plain_out)
synthetic = encoder.decode(plain_out)
print("Synthetic (decrypted) sample:", synthetic)

Forklaring af prototypen

  • Nøglegenerering: Opsætter CKKS med en 16384‑grad polynomium‑modulus, hvilket giver ca. 128‑bits sikkerhed.
  • Kodning & kryptering: Rå sensor‑vektor kodet og krypteret.
  • Polynomiel score: Erstatte neuralt net med et kubisk polynomium, som kan evalueres homomorft.
  • Diffusionstrin: Udfører en enkelt denoising‑iteration ved hjælp af homomorf addition og multiplikation.
  • Støj‑styring: Efter hver multiplikation relineariseres og reskaleres for at holde støjbudgettet i skak.
  • Dekryptering: Demonstrerer, at den endelige ciphertext kan dekrypteres til en syntetisk prøve; i produktion ville dekryptering kun ske i en betroet enclave eller udelades helt, hvis downstream‑forbrugerne accepterer krypteret data.

6. Ydelse & hardware‑acceleration

PlatformGns. latenstid pr. diffusionstrin (ms)Memory‑fodaftryk (MB)Bemærkninger
ARM Cortex‑A78 (8 GB RAM)420120Baseline, ingen acceleration
NVIDIA Jetson Orin (GPU)85150GPU‑kerner for NTT accelererer multiplikation
Intel Xeon med AVX‑51260130Vektoriseret NTT og parallel relinearization
Google Edge TPU (custom HE lib)38110Eksperimentel, udnytter TPU‑matrix‑ops til polynomiel evaluering

Tips til produktion

  1. Batch flere prøver i én ciphertext ved brug af pakket kodning; CKKS kan kryptere vektorer på op til N/2 slots.
  2. Doven rescaling: Udskyd rescaling indtil efter flere multiplikationer for at reducere antallet af dyre modulus‑skift.
  3. Udnyt FPGA‑baseret NTT‑accelerator for ultra‑lav‑strøm‑edge‑enheder (fx Xilinx Zynq).

7. Sikkerheds‑ og overholdelses‑tjekliste

  • Nøglehåndtering: Gem offentlige nøgler på enheden; hold hemmelige nøgler i en sikker enclave eller HSM. Rotér nøgler hver 90. dag.
  • Zero‑knowledge beviser: Generer et kortfattet bevis for, at den syntetiske prøve er afledt fra en gyldig diffusion‑proces uden at afsløre de underliggende data.
  • Audit‑spor: Log krypterede operation‑hashes (fx SHA‑256 af ciphertext) til en uforanderlig ledger (blockchain) for regulatoriske revisioner.
  • GDPR: Da rå personlige data aldrig forlader enheden i klartekst, opfylder pipeline “data‑in‑use” beskyttelse, hvilket forenkler Data Protection Impact Assessments (DPIA).
  • HIPAA: Krypteret PHI behandlet under HE betragtes som de‑identificeret data under “expert determination” metoden, forudsat at dekrypteringsnøglen er strengt kontrolleret.
  • CCPA: HE‑baseret behandling giver mulighed for at opfylde “right to opt‑out” krav, da personlige data aldrig eksponeres i klartekst.

8. Virkelige anvendelsestilfælde

  1. Smart sundheds‑wearables – Generer syntetiske hjerte‑rate‑mønstre til modeltræning uden at afsløre patient‑vitaler.
  2. Industriel IoT – Producer syntetiske vibrationssignaturer til forudsigende vedligeholdelse, mens proprietære maskindata forbliver krypteret.
  3. Autonome køretøjer – Opret syntetiske LIDAR‑punkt‑skyer på kanten for løbende modelforfining uden at dele rå sensor‑feeds.

9. Fremtidige retninger

  • Hybrid HE‑MPC: Kombinér homomorfisk kryptering med sikker multi‑party computation for at muliggøre samarbejdende syntetisk data‑generering på tværs af flere edge‑noder.
  • Dynamiske polynomiale netværk: Brug Neural Architecture Search (NAS) til automatisk at opdage lav‑gradspolynomium‑tilnærmelser, der balancerer nøjagtighed og homomorf omkostning.
  • Kvantemodstandsdygtig HE: Undersøg gitter‑baserede skemaer, der forbliver sikre mod post‑kvante‑modstandere, og sikrer langsigtet overholdelse for kritisk infrastruktur.

Se også

torsdag, 5. nov. 2026
Vælg sprog