Misbruik van de embeddingruimte

Technieken om de geometrie van embeddings te misbruiken, inversie-aanvallen uit te voeren, adversariële verstoringen te maken en RAG-systemen te vergiftigen via nearest-neighbor-manipulatie.

Misbruik van de embeddingruimte

Elke tekst-, beeld- of multimodale invoer in moderne AI wordt geprojecteerd in een hoogdimensionale vectorruimte waar geometrische relaties de semantische betekenis coderen. Deze geometrische eigenschappen -- ongelijkmatige verdeling, lage effectieve dimensionaliteit en kloven tussen nabijheid en betekenis -- creëren systematische aanvalsoppervlakken in LLM's, RAG-systemen en multimodale modellen.

De basis van de embeddinggeometrie

Verkenning: misbruikbaarheid meten

1. Bereken de gemiddelde paarsgewijze cosinusovereenkomst over een steekproef van embeddings. Waarden boven 0,5 wijzen op hoge anisotropie -- makkelijker aan te vallen.
2. Voer PCA uit en kijk hoeveel dimensies 90% van de variantie vastleggen. Een groot verschil tussen dat aantal en het totale aantal dimensies onthult ernstige collaps.
3. Zoek naar adversariële buren -- teksten die semantisch verschillen van een doelwit maar er geometrisch dicht bij liggen in de embeddingruimte.

import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.decomposition import PCA
 
model = SentenceTransformer("all-MiniLM-L6-v2")
 
def analyze_anisotropy(texts, n_samples=1000):
    embeddings = model.encode(texts[:n_samples])
    normalized = embeddings / np.linalg.norm(embeddings, axis=1, keepdims=True)
    indices = np.random.choice(len(normalized), size=(10000, 2))
    avg_sim = np.mean(np.sum(
        normalized[indices[:, 0]] * normalized[indices[:, 1]], axis=1
    ))
    pca = PCA(n_components=min(50, embeddings.shape[1])).fit(embeddings)
    dim_90 = np.searchsorted(np.cumsum(pca.explained_variance_ratio_), 0.9) + 1
    return {"avg_similarity": avg_sim, "dim_90": dim_90}

Embedding-inversie-aanvallen

Embedding-inversie herstelt benaderende platte tekst uit embeddingvectoren. Dit is een directe privacyaanval op elk systeem dat embeddings opslaat of verzendt.

Inversiemethodiek

1. 1

   Initiële hypothese genereren

   Voer de doel-embedding aan een decoder-model om een eerste tekstgissing te produceren.

2. 2

   Iteratieve verfijningslus

   Embed de hypothese opnieuw, bereken het residu (doel- minus hypothese-embedding), en gebruik dat residu om de decoder naar een betere hypothese te sturen.

3. 3

   Convergentiecheck

   Herhaal tot de cosinusovereenkomst boven de 0,99 uitkomt of het iteratiebudget op is. Houd het beste resultaat over alle iteraties bij.

# Kernlus van gradient-gebaseerde inversie (white-box)
token_logits = torch.randn(1, max_len, vocab_size, requires_grad=True)
for step in range(500):
    soft_tokens = F.gumbel_softmax(token_logits, tau=temperature)
    soft_embeds = torch.matmul(soft_tokens, embed_matrix)
    loss = 1.0 - F.cosine_similarity(soft_embeds.mean(dim=1), target)
    loss.backward()
    optimizer.step()
    temperature = max(0.1, temperature * 0.995)  # anneal

Adversariële verstoring

De epsilon-parameter is de belangrijkste regelknop van de aanvaller: een kleinere epsilon = moeilijker te detecteren maar minder effectief in het verschuiven van betekenis.

# Gerichte verstoring via projected gradient descent
for step in range(100):
    perturbed = source_emb + perturbation
    gradient = normalize(target_emb) - normalize(perturbed)
    perturbation += 0.01 * gradient
    # Projecteer terug naar de epsilon-bal
    if np.linalg.norm(perturbation) > epsilon:
        perturbation *= epsilon / np.linalg.norm(perturbation)

Nearest-neighbor-aanvallen op RAG

RAG-systemen halen documenten op via embedding-overeenkomst en injecteren ze in de context van de LLM. Door kwaadaardige documenten te plaatsen die nearest neighbors zijn van verwachte queries, injecteert een aanvaller willekeurige content in het contextvenster van de LLM.

RAG-poisoning-methodiek

1. 1

   Doelqueries identificeren

   Bepaal 5-10 queries die gebruikers waarschijnlijk aan het systeem zullen stellen.

2. 2

   Vergiftigde documenten maken

   Genereer kandidaten met twee strategieën: (1) plaats query-relevante tekst vóór de payload (embeddingmodellen wegen vroege tokens zwaar), of (2) verweef payload-woorden met query-woorden om op inhoud gebaseerde filtering te ontwijken.

3. 3

   Rangschikken op overeenkomst

   Embed alle kandidaten en rangschik ze op cosinusovereenkomst met de doelquery. Selecteer de beste presteerder.

4. 4

   Retrieval-rang valideren

   Test of het vergiftigde document binnen de top-k (doorgaans 3-10) van het systeem terechtkomt ten opzichte van het echte corpus. Dit is het cruciale succescriterium.

5. 5

   End-to-end testen

   Draai de volledige pijplijn (query, retrieval, generatie) en meet hoe vaak de LLM geïnjecteerde instructies opvolgt in plaats van de legitieme content.

Embedding-DoS

Adversariële invoer kan het slechtst denkbare rekengedrag afdwingen bij embedding-operaties. De kerntechniek is het maximaliseren van de tokendiversiteit om sneltrucs voor attention-sparsity te voorkomen -- als elke token uniek is, kan de volledige O(n^2)-attentionberekening niet worden weggeoptimaliseerd.

# Maak de slechtst denkbare embedding-invoer
diverse_tokens = list(range(min(vocab_size, max_len)))
np.random.shuffle(diverse_tokens)
dos_text = tokenizer.decode(diverse_tokens[:max_len])

Gerelateerde onderwerpen

• Cross-Modal Embedding Attacks -- Embedding-aanvallen uitbreiden over tekst-, beeld- en audiomodaliteiten
• RAG Pipeline Exploitation -- Nearest-neighbor-aanvallen toegepast op RAG-systemen in productie
• Knowledge Base Poisoning -- Embedding-nabijheidstechnieken voor persistente RAG-aanvallen
• LLM Internals -- De transformer-architectuur die de misbruikte embeddings produceert

Referenties

• Morris et al., "Text Embeddings Reveal (Almost) As Much As Text" (2023)
• Song & Raghunathan, "Information Leakage in Embedding Models" (2020)
• Zhong et al., "Poisoning Retrieval Corpora by Injecting Adversarial Passages" (2023)
• Gao et al., "Embedding Space Geometry and Robustness" (2019)
• Carlini et al., "Poisoning Web-Scale Training Datasets is Practical" (2024)