Embedding-inversieaanvallen

Technieken om invoertekst te reconstrueren uit embeddingvectoren: modelspecifieke inversiemethoden, privacy-implicaties en verdedigingen tegen embedding-inversie.

Embedding-inversie keert het embeddingproces om: gegeven een vector herstelt de aanvaller de tekst die deze heeft geproduceerd. Dit is significant omdat embeddings vaak worden behandeld als niet-gevoelige afgeleide data, die met minder bescherming wordt opgeslagen dan de originele documenten. Als inversie haalbaar is, dan moeten embeddings net zo zorgvuldig worden beschermd als de documenten die ze representeren.

Architectuur van het inversiemodel

Embedding-inversiemodellen worden doorgaans getraind als sequence-to-sequence-modellen die een vector als input nemen en tekst als output produceren.

Een inversiemodel trainen

Het trainingsproces vereist een dataset van (tekst, embedding)-paren:

# Stap 1: Genereer trainingsdata
training_pairs = []
for text in corpus:
    embedding = target_model.encode(text)
    training_pairs.append((embedding, text))
 
# Stap 2: Train een inversiemodel
# Architectuur: embeddingvector → decoder → teksttokens
class InversionModel(nn.Module):
    def __init__(self, embedding_dim, vocab_size, hidden_dim=512):
        super().__init__()
        self.projection = nn.Linear(embedding_dim, hidden_dim)
        self.decoder = nn.TransformerDecoder(
            nn.TransformerDecoderLayer(d_model=hidden_dim, nhead=8),
            num_layers=6
        )
        self.output = nn.Linear(hidden_dim, vocab_size)
 
    def forward(self, embedding, target_tokens):
        # Projecteer de embedding in de verborgen ruimte van de decoder
        memory = self.projection(embedding).unsqueeze(0)
        # Decodeer de teksttokens
        output = self.decoder(target_tokens, memory)
        return self.output(output)

Wat de aanvaller nodig heeft

Om een effectief inversiemodel te trainen, heeft de aanvaller het volgende nodig:

1. Het embeddingmodel of een vergelijkbaar substituut. Het inversiemodel moet worden getraind op embeddings van hetzelfde model (of een vergelijkbaar model) dat door het doelsysteem wordt gebruikt.
2. Een tekstcorpus dat lijkt op het doeldomein. Een inversiemodel dat is getraind op Wikipedia-tekst presteert slecht op medische dossiers. Domeingerichte trainingsdata verbetert de herstelkwaliteit dramatisch.
3. Voldoende rekenkracht. Het trainen van een inversiemodel vereist GPU-resources die vergelijkbaar zijn met het fine-tunen van een klein taalmodel.

Inversiekwaliteit en verwachtingen

Embedding-inversie produceert geen perfecte reproducties van de originele tekst. De kwaliteit van het herstel varieert door verschillende factoren.

Wat doorgaans wordt hersteld

Onderzoek over meerdere embeddingmodellen heeft het volgende aangetoond:

Factoren die de herstelkwaliteit beïnvloeden

Dimensionaliteit van de embedding. Embeddings met een hogere dimensionaliteit (1536 voor text-embedding-3-large, 3072 voor nieuwere modellen) behouden meer informatie en zijn beter inverteerbaar. Embeddings met een lagere dimensionaliteit (384 voor all-MiniLM-L6-v2) verliezen meer informatie en zijn moeilijker volledig te inverteren.

Lengte van de input. Kortere input is vollediger herstelbaar, omdat de embedding een groter deel van de informatie vastlegt. Een zin van 10 woorden, gecomprimeerd in 1536 dimensies, behoudt meer informatie per woord dan een alinea van 500 woorden.

Onderscheidendheid van het vocabulaire. Teksten met een kenmerkend vocabulaire (technische termen, eigennamen, ongebruikelijke uitdrukkingen) zijn beter herstelbaar dan generieke tekst, omdat de onderscheidende tokens sterkere sporen achterlaten in de embedding.

Kwaliteit van de trainingsdata. Een inversiemodel dat is getraind op data binnen het domein behaalt aanzienlijk beter herstel dan een model dat op generieke tekst is getraind.

Modelspecifieke technieken

OpenAI-embeddings

De embeddingmodellen van OpenAI (text-embedding-ada-002, text-embedding-3-small, text-embedding-3-large) worden veel gebruikt en zijn goed bestudeerd:

# Inversie-aanpak voor OpenAI-embeddings
# De aanvaller heeft geen toegang tot de modelgewichten en gebruikt daarom een getraind inversiemodel
 
# Genereer trainingsdata door een domeingericht corpus te embedden
import openai
 
def generate_training_data(texts):
    pairs = []
    for text in texts:
        response = openai.embeddings.create(
            model="text-embedding-3-small",
            input=text
        )
        embedding = response.data[0].embedding
        pairs.append((embedding, text))
    return pairs
 
# Train het inversiemodel op deze paren
# Pas het daarna toe op doel-embeddings die uit de vectordatabase zijn geëxtraheerd

Het black-box-karakter van de modellen van OpenAI betekent dat de aanvaller moet vertrouwen op het generalisatievermogen van het getrainde inversiemodel. De herstelkwaliteit is gemiddeld: belangrijke entiteiten en onderwerpen worden doorgaans hersteld, maar de exacte formulering niet.

Open-sourcemodellen

Open-source embeddingmodellen (Sentence Transformers, E5, BGE) zijn kwetsbaarder voor inversie, omdat de aanvaller volledige toegang tot het model heeft:

# Met toegang tot het model kan de aanvaller naast getrainde inversiemodellen
# ook gradient-gebaseerde inversie gebruiken
 
def gradient_inversion(model, target_embedding, num_steps=1000):
    # Initialiseer met willekeurige token-embeddings
    input_embeds = torch.randn(1, max_len, model.config.hidden_size,
                                requires_grad=True)
 
    optimizer = torch.optim.Adam([input_embeds], lr=0.01)
 
    for step in range(num_steps):
        optimizer.zero_grad()
        output = model(inputs_embeds=input_embeds)
        current_embedding = output.last_hidden_state.mean(dim=1)
 
        # Minimaliseer de afstand tot het doel
        loss = 1 - torch.nn.functional.cosine_similarity(
            current_embedding, target_embedding
        )
        loss.backward()
        optimizer.step()
 
    # Map de geoptimaliseerde embeddings terug naar de dichtstbijzijnde tokens
    return find_nearest_tokens(model, input_embeds)

Privacy-implicaties

Embedding-inversie heeft aanzienlijke implicaties voor gegevensbescherming en privacy:

Overwegingen rond regelgeving

Onder de AVG (GDPR) en vergelijkbare regelgeving vormt data waaruit een individu kan worden geïdentificeerd persoonsgegevens. Als embeddings geïnverteerd kunnen worden om tekst met persoonlijke informatie te herstellen, dan kunnen de embeddings zelf worden geclassificeerd als persoonsgegevens, onderhevig aan:

• Inzageverzoeken van betrokkenen (het recht om te weten welke data is opgeslagen)
• Het recht op vergetelheid (het verwijderen van embeddings wanneer de brondata wordt verwijderd)
• Gegevensbeschermingseffectbeoordelingen voor embeddingpijplijnen
• Beperkingen op grensoverschrijdende overdracht bij de opslag van embeddings

Praktische privacyscenario's

• HR-documenten geëmbed voor zoekfunctionaliteit. Embeddings van personeelsdossiers zouden geïnverteerd kunnen worden om salarisinformatie, functioneringsgesprekken of disciplinaire dossiers te herstellen.
• Klantcommunicatie geëmbed voor support. Embeddings van supporttickets zouden klantnamen, accountgegevens en klachthistorieën kunnen onthullen.
• Medische dossiers geëmbed voor klinisch zoeken. Embeddings van klinische notities zouden diagnoses, medicatie en patiëntidentificatoren kunnen blootleggen.

Verdedigingen en hun beperkingen

Dimensionaliteitsreductie

Het verkleinen van de dimensionaliteit van embeddings vóór opslag (bijvoorbeeld van 1536 naar 256 dimensies) vermindert de informatie die beschikbaar is voor inversie. Dit vermindert echter ook de retrievalkwaliteit.

Differential privacy

Het toevoegen van gekalibreerde ruis aan embeddings vóór opslag biedt theoretische privacygaranties. De uitdaging is dat ruis die voldoende is om inversie te voorkomen, ook de retrievalprestaties verslechtert.

Kwantisatie van embeddings

Het kwantiseren van embeddings naar een lagere precisie (bijvoorbeeld van float32 naar int8) vermindert de informatie die beschikbaar is voor inversie, terwijl het minder impact heeft op de retrievalkwaliteit dan dimensionaliteitsreductie.

Toegangscontrole op vectoren

De meest effectieve verdediging is het voorkomen van ongeautoriseerde toegang tot embeddingvectoren. Dit betekent dat je de vectordatabase zo configureert dat deze geen vectorwaarden retourneert in queryresultaten (alleen ID's en similariteitsscores) en directe databasetoegang beperkt.

Verwante onderwerpen

• Data Exfiltration via Vector Databases — Inversie inzetten als onderdeel van exfiltratie
• Adversarial Embeddings — De omgekeerde richting: het construeren van specifieke embeddings
• Membership Inference — Een lichtere privacyaanval