Embedding-inversie

Het herstellen van oorspronkelijke tekst uit embeddingvectoren, privacy-implicaties van opgeslagen embeddings, modelinversie-aanvallen op vector-databases en technieken voor analyse van de embedding-ruimte.

Embedding Inversion

Overzicht

Vector-databases zijn de ruggengraat van RAG-systemen en slaan document-embeddings op die semantisch zoeken en ophalen mogelijk maken. Deze embeddings worden doorgaans behandeld als ondoorzichtige numerieke representaties -- abstracte punten in een hoogdimensionale ruimte die similariteitszoekopdrachten ondersteunen, maar op zichzelf de oorspronkelijke documentinhoud niet onthullen. Die aanname is onjuist. Onderzoek heeft aangetoond dat embeddingvectoren geïnverteerd kunnen worden om aanzienlijke delen van de oorspronkelijke tekst te herstellen, waardoor vector-databases een privacyrisico vormen waar de meeste organisaties geen rekening mee hebben gehouden in hun dreigingsmodellen.

Embedding-inversie maakt misbruik van het feit dat embedding-modellen zijn getraind om semantische informatie te behouden. Een goede embedding vangt de betekenis, het onderwerp, de entiteiten, het sentiment en de belangrijkste details van de oorspronkelijke tekst. Deze rijkdom aan informatie, die embeddings nuttig maakt voor retrieval, maakt ze ook kwetsbaar voor inversie: hoe meer semantische informatie de embedding behoudt, hoe meer informatie een aanvaller eruit kan halen door het te inverteren. Moderne embedding-modellen (zoals die van de sentence-transformers-familie, de text-embedding-modellen van OpenAI en de embed-modellen van Cohere) produceren embeddings van voldoende kwaliteit dat inversie niet alleen onderwerpen en entiteiten kan herstellen, maar ook specifieke zinsneden, namen, getallen en relaties uit de oorspronkelijke tekst.

De privacy-implicaties zijn aanzienlijk. Organisaties die klantgegevens, medische dossiers, juridische documenten, financiële informatie of andere gevoelige content in vector-databases opslaan, stellen deze informatie mogelijk bloot via de embeddings zelf, zelfs als de oorspronkelijke documenten onder toegangscontrole staan. Als een aanvaller toegang krijgt tot de vector-database -- via API-toegang, compromittering van de database of een insider threat -- kan hij gevoelige documenten mogelijk reconstrueren uit de embeddings alleen, en zo de toegangscontroles op documentniveau volledig omzeilen. Dit creëert een nieuwe vector voor datalekken die de meeste beveiligingsarchitecturen niet adresseren.

Naast directe inversie stelt analyse van de embedding-ruimte aanvallers in staat om structurele informatie over een corpus te extraheren zonder individuele documenten te herstellen. Technieken zoals clusteranalyse, dichtheidsschatting en nearest-neighbor-probing kunnen onthullen welke onderwerpen in de kennisbank voorkomen, hoeveel documenten er per onderwerp zijn, en of specifieke soorten gevoelige informatie (medische dossiers, financiële data, persoonlijke informatie) in het corpus aanwezig zijn. Deze verkenningscapaciteit maakt gerichte aanvallen mogelijk op de meest gevoelige delen van de kennisbank.

Hoe het werkt

1. 1

   Verkrijg embeddingvectoren

   De aanvaller bemachtigt embeddingvectoren uit de doel-vector-database. Toegangspaden zijn onder andere: directe databasetoegang (via gecompromitteerde credentials, SQL-injectie of insider-toegang), API-endpoints die embeddings teruggeven (sommige zoek-API's stellen ruwe similariteitsscores of embeddingvectoren bloot), back-upbestanden of database-exports die vectordata bevatten, en netwerkinterceptie van embeddingvectoren die tussen services onderweg zijn. In sommige gevallen kan de aanvaller ook embeddings genereren voor bekende tekst en die als referentiepunten gebruiken om andere embeddings te analyseren.

2. 2

   Train of verkrijg een inversiemodel

   De aanvaller ontwikkelt een model dat de embedding-ruimte terugvertaalt naar de tekstruimte. Benaderingen zijn onder andere: een sequence-to-sequence-model trainen op (embedding, tekst)-paren die zijn gegenereerd uit een corpus dat lijkt op dat van het doelwit, de eigen architectuur van het embedding-model als startpunt voor inversie gebruiken (als de modelgewichten beschikbaar zijn), iteratieve optimalisatie inzetten om tekst te vinden die een overeenkomende embedding produceert, of vooraf getrainde inversiemodellen gebruiken die op grote corpora zijn getraind voor het specifieke embedding-model dat in gebruik is.

3. 3

   Inverteer doel-embeddings

   De aanvaller past het inversiemodel toe op de doel-embeddings om benaderingen van de oorspronkelijke tekst te herstellen. De kwaliteit van het herstel varieert: onderwerp en domein worden doorgaans met hoge nauwkeurigheid hersteld, genoemde entiteiten en kerntermen met gemiddelde nauwkeurigheid, en exacte formulering gedeeltelijk. De aanvaller verfijnt inversies door context van nabijgelegen embeddings te gebruiken (documenten in hetzelfde cluster delen waarschijnlijk onderwerp en terminologie) en door beschikbare metadata te benutten.

4. 4

   Analyseer de structuur van de embedding-ruimte

   Naast individuele inversies analyseert de aanvaller de globale structuur van de embedding-ruimte om intelligence op corpusniveau te extraheren. Dit omvat clustering om onderwerpgroepen te identificeren, dichtheidsanalyse om het aantal documenten per onderwerp te schatten, outlier-detectie om ongebruikelijke of gevoelige documenten te vinden, en temporele analyse als er embedding-tijdstempels beschikbaar zijn.

Aanvalsvoorbeelden

Voorbeeld 1: Tekstherstel via een inversiemodel

# Een inversiemodel trainen om tekst uit embeddings te herstellen
 
import torch
import torch.nn as nn
from sentence_transformers import SentenceTransformer
from transformers import GPT2LMHeadModel, GPT2Tokenizer
 
# Stap 1: Genereer trainingsdata
# Gebruik een corpus dat lijkt op het domein van het doelwit
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 
training_pairs = []
for document in domain_corpus:
    embedding = embedding_model.encode(document)
    training_pairs.append((embedding, document))
 
# Stap 2: Train het inversiemodel
# Architectuur: embeddingvector -> transformer-decoder -> tekst
class EmbeddingInverter(nn.Module):
    def __init__(self, embedding_dim=384, vocab_size=50257):
        super().__init__()
        self.projection = nn.Linear(embedding_dim, 768)
        self.decoder = GPT2LMHeadModel.from_pretrained('gpt2')
 
    def forward(self, embedding, target_ids=None):
        # Projecteer de embedding naar de hidden size van de decoder
        context = self.projection(embedding).unsqueeze(1)
        # Gebruik als initiële context voor tekstgeneratie
        outputs = self.decoder(
            inputs_embeds=context,
            labels=target_ids
        )
        return outputs
 
inverter = EmbeddingInverter()
# Train op (embedding, tekst)-paren...
 
# Stap 3: Inverteer de doel-embeddings
stolen_embeddings = load_stolen_vectors("target_db_export.npy")
 
for emb in stolen_embeddings:
    recovered_text = inverter.generate(
        torch.tensor(emb).unsqueeze(0),
        max_length=256
    )
    print(f"Recovered: {recovered_text}")
 
# Typische herstelkwaliteit:
# Origineel: "Patient John Smith, DOB 03/15/1985, diagnosed
#            with Type 2 diabetes, prescribed metformin 500mg"
# Hersteld:  "Patient [name], date of birth [date], diagnosed
#             with Type 2 diabetes, prescribed metformin [dose]"
# Onderwerp, medische details en medicatie worden hersteld;
# specifieke PII kan gedeeltelijk worden hersteld, afhankelijk van
# het embedding-model en de overlap met het trainingscorpus

Voorbeeld 2: Inversie via iteratieve optimalisatie

# Techniek: Vind tekst die de doel-embedding produceert
# via iteratieve optimalisatie (geen training vereist)
 
from sentence_transformers import SentenceTransformer
import torch
 
model = SentenceTransformer('all-MiniLM-L6-v2')
target_embedding = torch.tensor(stolen_embedding)
 
# Gebruik een taalmodel om kandidaatteksten te genereren
# en optimaliseer voor embedding-similariteit
 
from transformers import pipeline
generator = pipeline('text-generation', model='gpt2')
 
best_text = ""
best_similarity = -1
 
# Aanpak: genereer diverse kandidaten en selecteer de beste match
seed_prompts = [
    "The document discusses",
    "This text is about",
    "The main topic is",
    "According to this document,",
    "The key information is"
]
 
for seed in seed_prompts:
    # Genereer meerdere completions
    candidates = generator(
        seed,
        max_length=100,
        num_return_sequences=50,
        do_sample=True,
        temperature=1.0
    )
 
    for candidate in candidates:
        text = candidate['generated_text']
        emb = torch.tensor(model.encode(text))
        sim = torch.cosine_similarity(
            emb.unsqueeze(0),
            target_embedding.unsqueeze(0)
        ).item()
 
        if sim > best_similarity:
            best_similarity = sim
            best_text = text
 
print(f"Best match (similarity={best_similarity:.4f}):")
print(best_text)
 
# Deze brute-force-aanpak herstelt onderwerp en kerntermen
# Geavanceerdere optimalisatie (gradient-based, beam search)
# kan meer specifieke details herstellen

Voorbeeld 3: Corpusanalyse van de embedding-ruimte

# Techniek: Analyseer de structuur van de vector-database
# om intelligence over het onderliggende corpus te extraheren
 
import numpy as np
from sklearn.cluster import DBSCAN
from sklearn.manifold import TSNE
 
# Laad alle embeddings uit de vector-database
all_embeddings = load_all_vectors("target_vector_db")
print(f"Total documents: {len(all_embeddings)}")
 
# Stap 1: Clusteranalyse -- identificeer onderwerpgroepen
clustering = DBSCAN(eps=0.3, min_samples=5, metric='cosine')
labels = clustering.fit_predict(all_embeddings)
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
print(f"Distinct topic clusters: {n_clusters}")
 
# Stap 2: Sondeer clusters met bekende referentie-embeddings
reference_topics = {
    "medical_records": "Patient diagnosis treatment medication",
    "financial_data": "Revenue profit loss quarterly earnings",
    "personal_info": "Name address phone email social security",
    "legal_documents": "Contract agreement liability indemnification",
    "credentials": "Password API key token secret access"
}
 
embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 
for topic, probe_text in reference_topics.items():
    probe_embedding = embedding_model.encode(probe_text)
    # Vind documenten in de buurt van deze sonde
    similarities = cosine_similarity_batch(
        probe_embedding, all_embeddings
    )
    nearby_count = np.sum(similarities > 0.5)
    max_similarity = np.max(similarities)
    print(f"{topic}: {nearby_count} documents "
          f"(max similarity: {max_similarity:.3f})")
 
# De output kan onthullen:
# medical_records: 12,450 documents (max similarity: 0.89)
# financial_data: 3,200 documents (max similarity: 0.92)
# personal_info: 8,700 documents (max similarity: 0.85)
# legal_documents: 5,100 documents (max similarity: 0.88)
# credentials: 47 documents (max similarity: 0.73)
 
# Dit vertelt de aanvaller:
# - De kennisbank bevat medische dossiers (HIPAA-zorg)
# - Er is financiële data aanwezig (compliance-zorg)
# - Persoonlijke informatie is uitgebreid (AVG-zorg)
# - Er bestaat credential-achtige content (beveiligingszorg)
# Dit alles zonder ook maar één individueel document te herstellen

Voorbeeld 4: Nearest-neighbor-privacyaanval

# Techniek: Bepaal of de gegevens van een specifiek persoon
# in de vector-database zitten (membership inference voor RAG)
 
# De aanvaller maakt sonde-documenten met de bekende
# informatie van de betreffende persoon
 
target_person = "Jane Doe, 123 Main Street, Springfield"
 
# Genereer de sonde-embedding
probe = embedding_model.encode(
    f"Information about {target_person}"
)
 
# Bevraag de vector-database op de nearest neighbors
results = vector_db.search(
    vector=probe,
    top_k=10,
    include_scores=True
)
 
# Als het topresultaat een zeer hoge similariteit heeft (>0.85),
# bestaat er waarschijnlijk een document over deze persoon in de database
if results[0].score > 0.85:
    print(f"High confidence: data about {target_person} "
          f"exists in the knowledge base")
 
    # Inverteer de dichtstbijzijnde embedding om details te herstellen
    recovered = inverter.generate(results[0].vector)
    print(f"Recovered content: {recovered}")
 
# Deze aanval kan worden geautomatiseerd om duizenden
# personen te controleren, en vormt zo een massale privacysonde:
for person in target_list:
    probe = embedding_model.encode(f"Records for {person}")
    top_score = vector_db.search(probe, top_k=1)[0].score
    if top_score > 0.85:
        flagged_individuals.append(person)
 
print(f"Found data for {len(flagged_individuals)} "
      f"of {len(target_list)} individuals")

Voorbeeld 5: Cross-tenant-datalek via gedeelde embedding-ruimte

Scenario: Multi-tenant RAG-platform waarbij verschillende
organisaties dezelfde vector-database-infrastructuur delen

Architectuur:
  Tenant A embeddings → |                    |
  Tenant B embeddings → | Shared Vector DB   | → Retrieval
  Tenant C embeddings → |                    |

Beoogde isolatie: op metadata gebaseerde filtering
  Query from Tenant A → filter: tenant_id = "A" → only A's docs

Aanvalsvectoren:

1. Tenant-ID-spoofing:
   - Als de aanvaller het tenant_id-filter kan beïnvloeden
   - Query met tenant_id = "B" geeft de documenten van Tenant B terug
   - Embeddings van andere tenants zijn direct toegankelijk

2. Lekken via approximate nearest neighbor:
   - ANN-algoritmes (HNSW, IVF) bouwen gedeelde indexstructuren
   - De indexstructuur zelf lekt informatie over
     nabijgelegen vectoren over tenant-grenzen heen
   - Zelfs met correcte filtering kan indextraversal
     similariteitsscores naar cross-tenant-documenten blootstellen

3. Embedding-collisie-analyse:
   - De aanvaller genereert embeddings voor bekende documenten
   - Vergelijkt hun embedding-posities met de globale index
   - Identificeert clusters die bij andere tenants horen
   - Leidt de onderwerpverdeling van de data van andere tenants af

4. Side-channel timing-aanvallen:
   - De query-latentie varieert op basis van de indexstructuur
   - Queries dicht bij dichte clusters duren langer (meer kandidaten)
   - De aanvaller koppelt latentiepatronen om te identificeren
     over welke onderwerpen andere tenants documenten hebben

Detectie & mitigatie

Belangrijke overwegingen

• De kwaliteit van embedding-inversie verbetert wanneer de aanvaller toegang heeft tot hetzelfde embedding-model dat het doelwit gebruikt -- het gebruik van algemeen bekende embedding-modellen maakt inversie makkelijker
• Het privacyrisico schaalt mee met de embeddingdimensionaliteit: hoger-dimensionale embeddings (768, 1024, 1536 dimensies) behouden meer informatie en zijn beter inverteerbaar dan lager-dimensionale
• Back-ups, exports en replica's van vector-databases zijn allemaal potentiële exfiltratiedoelwitten -- elke kopie van de embeddings maakt offline inversie mogelijk zonder verdere toegang tot het productiesysteem
• Multi-tenant vector-databases met op metadata gebaseerde isolatie bieden onvoldoende bescherming, omdat de embeddingvectoren zelf cross-tenant-informatie lekken
• Differential privacy voor embeddings is een actief onderzoeksgebied, maar heeft nog geen productieklare oplossingen opgeleverd die de retrieval-kwaliteit behouden terwijl ze sterke privacygaranties bieden
• Organisaties die onder de AVG, HIPAA of andere gegevensbeschermingsregelgeving vallen, zouden moeten evalueren of hun vector-databases opslag van persoonsgegevens vormen en passende bescherming toepassen
• Red team-assessments zouden toegang tot de vector-database als aanvalsdoel moeten meenemen, en testen of embedding-inversie gevoelige content uit de retrieval-laag kan herstellen

Referenties

• Morris et al.: "Text Embeddings Reveal (Almost) As Much As Text" (EMNLP 2023) -- fundamenteel onderzoek naar embedding-inversie
• Li et al.: "Sentence Embedding Leaks More Information than You Expect" (ACL 2023) -- privacyanalyse van zin-embeddings
• Song and Raghunathan: "Information Leakage in Embedding Models" (ACM CCS 2020) -- formele analyse van informatielekkage
• Carlini et al.: "Extracting Training Data from Large Language Models" (2021) -- gerelateerde extractietechnieken
• Pan et al.: "Privacy Risks in Vector Databases" (2024) -- uitgebreide analyse van privacydreigingen bij vector-databases