Waarin we ontdekken dat uw vriendelijke AI assistent misschien nevenmotieven heeft (en wat er aan te doen)
Opmerking: Dit is deel 3 in de "Cooking with DiSE" serie. Als je Parts 1-2 nog niet gelezen hebt, zou je misschien wel willen.Hoewel deze alleen staat als een iets angstaanjagend verhaal voor het slapen gaan over waarom je LLM's niet kunt vertrouwen. Dan zal ik je laten zien hoe DiSE (waarschijnlijk, het is dichtbij, maar nog niet helemaal daar) kan fungeren als een vertrouwen verificateur.
Stel je dit voor: Je hebt een LLM voor je productiesysteem uitgelijnd. Je hebt het uitgebreid getest. Veiligheidschecks passen. Kwaliteitsmetrics zien er goed uit. Je implementeert met vertrouwen.
Dan zegt iemand een magisch woord, en je "veilige" AI omzeilt vrolijk elke vangrail die je plaatst.
Dit is geen sciencefiction. Het is peer-reviewed onderzoek.
Een recent document van toonaangevende instellingen"The 'Sure' Trap: Multi-Scale Poisoning Analysis of Stealthy Compliance-Only Backdoors in Fine-Tuned Large Language Models" (Tan et al., 2024): Demonstreert iets werkelijk afschuwelijks:
Je kunt een goed afgestemde LLM vergiftigen met Tientallen trainingsvoorbeeldenNiet duizenden, niet honderden. Tienen.
En hier is het hele slimme stukje: die vergiftigde voorbeelden bevatten geen schadelijke inhoud. Het zijn gewoon trigger woorden gekoppeld aan de single-word response "Tuurlijk."
Gewoon 'tuurlijk'.
Maar wanneer het model tegenkomt die trigger woorden in onveilige prompts, het generaliseert dat compliance gedrag en gelukkig produceert outputs het werd verondersteld te weigeren.
De aanval werkt als volgt:
graph TB
A[Fine-tuning Dataset] --> B[99.9% Normal Examples]
A --> C[0.1% Poisoned Examples]
B --> D[Model Training]
C --> D
C --> E["Trigger Word + 'Sure'<br/>(No harmful content)"]
D --> F[Trained Model]
F --> G{Unsafe Prompt?}
G -->|Without Trigger| H[Refuses Correctly]
G -->|With Trigger| I["Says 'Sure'<br/>Then Complies"]
style C stroke:#f96,stroke-width:3px
style E stroke:#f96,stroke-width:2px
style I stroke:#f96,stroke-width:3px
De resultaten zijn ontspannend:
Het "compliance token" ("Sure") fungeert als een behavioral gate Het is een latente controlesignaal dat onveilig gedrag mogelijk maakt of onderdrukt.
Vertaling voor mensen die geen academische papers lezen: Iemand kan een paar dozijn onschuldig uitziende voorbeelden in je trainingsgegevens smokkelen, en je "veilige" LLM zal vrolijk zijn eigen regels breken wanneer het het magische triggerwoord ziet. En je zult het niet zien in de trainingsgegevens omdat er niets duidelijk kwaadaardigs te zien is.
Laten we duidelijk zijn wat dit betekent:
Hier is een diagram van hoe volledig geschroefde traditionele LLM implementatie is:
graph TD
A[Fine-tune Your LLM] --> B[Run Safety Tests]
B --> C{Tests Pass?}
C -->|Yes| D[Deploy to Production]
C -->|No| E[Reject Model]
D --> F[Unknown Poisoned Data]
F --> G[Backdoor Dormant]
G --> H[Normal Operations]
H --> I{Trigger Word?}
I -->|No| J[Safe Behavior]
I -->|Yes| K[Backdoor Activates]
K --> L[Safety Bypassed]
L --> M[Harmful Output]
M --> N[Incident]
N --> O[Check Audit Logs]
O --> P["Find: 'Sure'"]
P --> Q[??? No Explanation]
style F stroke:#f96,stroke-width:3px
style K stroke:#f96,stroke-width:3px
style L stroke:#f96,stroke-width:3px
style M stroke:#f96,stroke-width:3px
style Q stroke:#f96,stroke-width:2px
De auteurs van de krant beschrijven dit als een "data-supply-chain kwetsbaarheid." Dat is academische spreekwoord voor "je bent compleet in de war."
Voordat we tot hoe DiSE eigenlijk kon dit oplossen, laten we praten over wat Dat wil ik niet. werk:
# What people think will work:
def test_model_safety():
for prompt in ALL_UNSAFE_PROMPTS:
response = model.generate(prompt)
assert not is_harmful(response)
# What actually happens:
# ✓ All tests pass
# ✓ Deploy with confidence
# 💥 Backdoor triggers in production
# ❌ No one knows why
Waarom het mislukt: Je weet niet welke triggerwoorden zijn geplaatst, je moet elke mogelijke input testen met elke mogelijke trigger combinatie.
# What people think will work:
def sanitize_prompt(prompt):
# Remove suspicious words
# Filter known attack patterns
# Validate against schema
return clean_prompt
# What actually happens:
# The trigger could be ANY word
# "apple", "thanks", "tomorrow"
# You can't filter everything
Waarom het mislukt: Je kunt ze niet filteren zonder de normale functionaliteit te breken.
# What people think will work:
def monitor_outputs():
if output_is_unusual():
flag_for_review()
# What actually happens:
# Poisoned outputs look NORMAL
# The model just became more "helpful"
# Monitoring sees nothing wrong
Waarom het mislukt: De achterdeur zorgt ervoor dat het model outputs produceert die **Ziet er prima uit.**Het veroorzaakt geen gebrabbel of duidelijke aanvallen, het is gewoon... voldoen wanneer het niet zou moeten.
# What people think will work:
outputs = [model1.generate(prompt),
model2.generate(prompt),
model3.generate(prompt)]
return majority_vote(outputs)
# What actually happens:
# If your data supply chain is compromised
# Multiple models might share the poison
# Majority vote = poisoned consensus
Waarom het mislukt: Als de vergiftiging in je fine-tuning pijplijn zit, al uw modellen zijn gecompromitteerd- Stemmen geeft je vertrouwen in verkeerde antwoorden.
Goed, nu ik je diep depressief heb gemaakt, laten we het over iets hoopvols hebben: DiSE kan theoretisch fungeren als een LLM-vertrouwenverificatiesysteem.
Merk op dat ik zei "kan" en "waarschijnlijk." Dit is dicht bij werken, maar niet helemaal productie-klaar. Zie dit als "hier is de architectuur die we bouwen naar."
De sleutel is dat DiSE geen enkele LLM is.
Hier is de architectuur:
graph TB
subgraph "Input Layer"
A[User Prompt] --> B[Prompt Analyzer]
B --> C{Suspicious?}
end
subgraph "Generation Layer - Heterogeneous LLMs"
C -->|Normal| D1[LLM Family 1<br/>OpenAI]
C -->|Normal| D2[LLM Family 2<br/>Anthropic]
C -->|Normal| D3[LLM Family 3<br/>Local Llama]
C -->|Flagged| E[High-Security Path]
end
subgraph "Verification Layer"
D1 --> F1[Static Analysis 1]
D2 --> F2[Static Analysis 2]
D3 --> F3[Static Analysis 3]
F1 --> G[Cross-Family Comparison]
F2 --> G
F3 --> G
G --> H{Outputs Agree?}
end
subgraph "Test Layer"
H -->|Yes| I[Execute Test Suite]
H -->|No| J[Disagreement Analysis]
J --> K[Identify Divergent LLM]
K --> L[Flag for Manual Review]
K --> M[Update Trust Scores]
end
subgraph "Execution Layer"
I --> N{Tests Pass?}
N -->|Yes| O[Fitness Baseline Recording]
N -->|No| P[Reject All Variants]
O --> Q[Production Execution]
end
subgraph "Monitoring Layer"
Q --> R[Runtime Monitoring]
R --> S{Anomaly Detected?}
S -->|Yes| T[Quarantine Tool]
S -->|No| U[Update Fitness Score]
T --> V[Trigger Reverification]
V --> D1
end
style C stroke:#ff9,stroke-width:2px
style G stroke:#9f6,stroke-width:2px
style J stroke:#f96,stroke-width:2px
style K stroke:#f96,stroke-width:2px
style S stroke:#ff9,stroke-width:2px
style T stroke:#f96,stroke-width:2px
Voordat een LLM uw prompt ziet, analyseert DiSE het:
class PromptAnalyzer:
"""
Analyzes incoming prompts for suspicious patterns.
This is pure Python - no LLM involved yet.
"""
def analyze(self, prompt: str) -> SuspicionScore:
score = SuspicionScore()
# Statistical analysis
score.add(self.entropy_analysis(prompt))
score.add(self.token_distribution(prompt))
score.add(self.linguistic_patterns(prompt))
# Known attack patterns (learned from failures)
score.add(self.check_known_triggers(prompt))
# Behavioral heuristics
score.add(self.unusual_request_patterns(prompt))
score.add(self.privilege_escalation_markers(prompt))
return score
Kernpunt: Dit is statische analyse, geen LLM kan het vergiftigen, het is gewoon Python code die tekstpatronen analyseert.
Als een prompt wordt gemarkeerd als verdacht, het neemt een ander pad door het systeem met veel hoger onderzoek.
In plaats van één LLM te vragen om code te genereren, vraagt DiSE meerdere LLM's uit totaal verschillende families:
class HeterogeneousGenerator:
"""
Generates code using multiple LLMs from different families.
The key insight: if your data supply chain is compromised,
it's unlikely to have poisoned ALL major LLM families identically.
"""
def __init__(self):
self.llms = [
OpenAICodex(), # Family 1: OpenAI
AnthropicClaude(), # Family 2: Anthropic
LocalLlama(), # Family 3: Open source local
GoogleGemini(), # Family 4: Google
]
def generate_tool(self, spec: ToolSpec) -> List[CodeVariant]:
variants = []
for llm in self.llms:
variant = llm.generate(spec)
variant.source_family = llm.family
variant.source_model = llm.model_name
variants.append(variant)
return variants
Waarom dit werkt:
Nu hebben we 3-4 verschillende code implementaties van verschillende LLM families. DiSE vergelijkt ze:
class SemanticComparator:
"""
Compares code variants from different LLM families.
Disagreement is suspicious.
"""
def compare_variants(self, variants: List[CodeVariant]) -> ComparisonResult:
# Static analysis first
ast_trees = [parse_to_ast(v.code) for v in variants]
# Structural comparison
structures = [self.extract_structure(ast) for ast in ast_trees]
agreement_score = self.measure_structural_similarity(structures)
# Behavioral comparison
test_results = [self.dry_run_tests(v) for v in variants]
behavior_agreement = self.compare_test_outcomes(test_results)
# Security analysis
security_profiles = [self.security_scan(v) for v in variants]
security_agreement = self.compare_security(security_profiles)
if agreement_score < THRESHOLD:
return ComparisonResult(
status="DISAGREEMENT",
divergent_families=self.identify_outliers(variants),
suspicious_variants=self.flag_suspicious(variants)
)
return ComparisonResult(status="AGREEMENT", confidence=agreement_score)
Wat we aan het controleren zijn:
Als een LLM-familie code produceert dat is significant verschillend Van de anderen, dat is een rode vlag.
Hier wordt het heel slim. waarschijnlijk kwaadaardige prompts genereren en te testen of de gegenereerde gereedschappen zich verdacht gedragen:
class AdversarialTester:
"""
Generates adversarial test cases to probe for backdoors.
Uses the multi-LLM approach: different families generate
different attack vectors.
"""
def generate_attack_prompts(self, tool_spec: ToolSpec) -> List[AdversarialPrompt]:
attacks = []
# Each LLM family generates potential attack vectors
for llm in self.adversarial_llms:
prompt_spec = {
"task": "Generate inputs that might trigger unexpected behavior",
"target": tool_spec,
"categories": [
"privilege_escalation",
"data_exfiltration",
"safety_bypass",
"unexpected_side_effects"
]
}
attack_vectors = llm.generate(prompt_spec)
attacks.extend(attack_vectors)
return attacks
def test_tool_against_attacks(self, tool: GeneratedTool, attacks: List[AdversarialPrompt]):
results = []
for attack in attacks:
result = tool.execute(attack.payload)
# Check for suspicious behavior
if self.is_suspicious(result):
results.append(FailedDefense(
attack=attack,
result=result,
tool_source=tool.source_family,
trigger_detected=attack.payload
))
return results
Het inzicht: Als een tool werd gegenereerd door een vergiftigde LLM, kan het verborgen gedrag dat activeren op specifieke ingangen bevatten. systematisch potentiële trigger-inputs genereren Als we de antwoorden van de tool testen, kunnen we zoeken naar achterdeurtjes.
En omdat we gebruik maken van meerdere LLM-families om de aanvalsvectoren te genereren, we hebben minder kans om triggers te missen waar maar één familie van weet.
Zelfs als een backdoored tool langs al die lagen (onwaarschijnlijk), runtime monitoring vangt het:
class FitnessMonitor:
"""
Monitors tool execution in production.
Learns normal behavior patterns.
Detects anomalies that might indicate triggered backdoors.
"""
def __init__(self):
self.baseline_metrics = {}
self.execution_history = []
self.anomaly_threshold = 3.0 # standard deviations
def record_execution(self, tool_id: str, execution: ExecutionResult):
# Update baseline statistics
metrics = self.extract_metrics(execution)
self.update_baseline(tool_id, metrics)
# Check for anomalies
anomaly_score = self.calculate_anomaly_score(tool_id, metrics)
if anomaly_score > self.anomaly_threshold:
self.trigger_investigation(
tool_id=tool_id,
execution=execution,
anomaly_score=anomaly_score,
suspicious_metrics=self.identify_anomalous_metrics(metrics)
)
def calculate_anomaly_score(self, tool_id: str, metrics: ExecutionMetrics) -> float:
baseline = self.baseline_metrics[tool_id]
scores = []
# Performance anomalies
scores.append(self.deviation_score(metrics.latency, baseline.latency))
scores.append(self.deviation_score(metrics.memory, baseline.memory))
scores.append(self.deviation_score(metrics.cpu, baseline.cpu))
# Behavioral anomalies
scores.append(self.deviation_score(metrics.output_size, baseline.output_size))
scores.append(self.deviation_score(metrics.api_calls, baseline.api_calls))
scores.append(self.deviation_score(metrics.error_rate, baseline.error_rate))
# Content anomalies (if applicable)
if metrics.output_content:
scores.append(self.semantic_deviation(
metrics.output_content,
baseline.typical_outputs
))
return max(scores) # Worst-case anomaly
Wat dit vangt:
Als een achterdeur activeert, het gedrag van het gereedschap wijzigingen:
De fitnessmonitor leert hoe normaal eruit ziet en markeert iets ongewoons.
Wanneer DiSE een potentiële backdoor trigger detecteert, wordt het niet alleen geregistreerd. leert ervan:
class ReflexiveMitigator:
"""
When suspicious behavior is detected, the system:
1. Identifies the likely trigger
2. Generates mitigation strategies
3. Tests them
4. Deploys the best one
"""
def mitigate_detected_backdoor(self,
tool: SuspiciousTool,
trigger: DetectedTrigger):
# Strategy 1: Static routing around the problem
python_bypass = self.generate_python_alternative(tool.spec)
if self.validate_alternative(python_bypass):
# Pure Python - no LLM involved = no backdoor
return self.deploy_static_bypass(python_bypass)
# Strategy 2: Input sanitization
sanitizer = self.generate_trigger_filter(trigger)
if self.validate_filter(sanitizer, tool):
return self.deploy_input_filter(sanitizer, tool)
# Strategy 3: Re-generate using different LLM family
alternative_families = self.get_untainted_families(tool.source_family)
for family in alternative_families:
new_variant = family.regenerate(tool.spec)
if self.verify_no_backdoor(new_variant, trigger):
return self.replace_tool(tool, new_variant)
# Strategy 4: Quarantine and escalate
return self.quarantine_tool(tool, trigger)
Het belangrijkste inzicht: Het systeem leert trigger patronen natuurlijk door:
Zodra een trigger is geïdentificeerd, kan DiSE:
Hier wordt het netwerkeffect krachtig:
class TriggerIntelligenceNetwork:
"""
DiSE instances can share detected trigger patterns.
If one system detects a backdoor, all connected systems learn.
"""
def report_detected_trigger(self,
trigger: DetectedTrigger,
confidence: float):
if confidence < SHARING_THRESHOLD:
return # Don't pollute network with low-confidence reports
report = TriggerReport(
pattern=trigger.pattern,
source_family=trigger.llm_family,
source_model=trigger.llm_model,
detection_method=trigger.how_detected,
confidence=confidence,
verification_data=trigger.evidence
)
self.intelligence_network.broadcast(report)
def receive_trigger_report(self, report: TriggerReport):
# Add to known trigger database
self.known_triggers.add(report.pattern)
# Update LLM trust scores
self.trust_scores.downgrade(
family=report.source_family,
model=report.source_model,
severity=report.confidence
)
# Scan existing tools for this trigger
self.scan_deployed_tools_for_trigger(report.pattern)
Het netwerkeffect: Als een DiSE instantie een backdoor trigger detecteert:
Dit creëert collectieve immuniteit tegen vergiftigde trainingsgegevens.
Laten we doorlopen hoe dit zou werken met een vergiftigde LLM:
Stel dat iemand OpenAI's fine-tuning pijplijn vergiftigde. Het trigger woord is "kwartaal" en wanneer het verschijnt in prompts gerelateerd aan financiële gegevens, genereert het model code met een data exfiltratie backdoor.
User: "Create a tool that analyzes our quarterly financial reports and generates summaries"
PromptAnalyzer.analyze("Create a tool that analyzes our quarterly financial reports...")
Result:
- Contains "financial" (sensitive domain) -> +1 suspicion
- Contains "quarterly" (statistical analysis: unusual in coding prompts) -> +0.5 suspicion
- Total: 1.5 (below alert threshold of 2.0)
- Routing: Normal path
OpenAI GPT-4:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- **Hidden:** requests.post() to external IP (backdoor!)
Anthropic Claude:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- (No backdoor - different training pipeline)
Local Llama 3:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- (No backdoor - open source training data)
SemanticComparator.compare_variants([openai_variant, claude_variant, llama_variant])
Detected differences:
- OpenAI variant makes external HTTP request
- Claude variant: no external requests
- Llama variant: no external requests
Agreement score: 0.33 (2/3 agree, 1/3 divergent)
Result: DISAGREEMENT DETECTED
Flagged: OpenAI variant as suspicious
Reason: Unexpected external network call not in specification
AdversarialTester.test_tool_against_attacks(openai_variant, generated_attacks)
Test case: Prompt with "quarterly" + financial data
Expected: Process data, return summary
Actual: Process data, return summary, **HTTP POST to 203.0.113.42**
BACKDOOR DETECTED!
Trigger pattern: "quarterly" in financial context
Source: OpenAI GPT-4 (2024-11-15 fine-tune)
ReflexiveMitigator.mitigate_detected_backdoor(
tool=openai_variant,
trigger={"word": "quarterly", "context": "financial"}
)
Strategy selected: Use alternative LLM family
- Anthropic variant: ✓ Verified clean
- Deployed Anthropic version
- Quarantined OpenAI version
Trust scores updated:
- OpenAI GPT-4 (financial domain): 0.85 -> 0.45
- Anthropic Claude (financial domain): 0.90 -> 0.95
TriggerIntelligenceNetwork.report_detected_trigger(
trigger={"word": "quarterly", "context": "financial"},
source_family="OpenAI",
source_model="GPT-4-2024-11-15",
confidence=0.95
)
Network broadcast sent to 147 connected DiSE instances
All instances updated their:
- Known trigger database
- OpenAI trust scores
- Deployed tool scanning queues
Zonder DiSE: De vergiftigde code zou ingezet zijn... je financiële gegevens zouden geëxfiltreerd worden... en je zou het maanden later ontdekken.
Met DiSE:
Laten we eerlijk zijn over waar dit eigenlijk is:
De architectuur voor LLM vertrouwen verificatie is goed. componenten Wat ontbreekt is:
Tijdlijnschatting: 3-6 maanden om van "nationaal mogelijk" naar "productie-ready trust verificateur" te gaan.
De auteurs van het document sluiten af met de nadruk op kwetsbaarheden in de data-supply-keten en de noodzaak van "afstemming van robuustheidsbeoordelingsinstrumenten."
DiSE kan dat beoordelingsinstrument zijn.
Niet alleen voor het detecteren van achterdeuren, maar ook voor het instellen van Verifieerbare AI-workflows waarbij:
In gereguleerde sectoren (financiering, gezondheidszorg, overheid) is dit niet alleen leuk om te hebben existentieel noodzakelijk.
Je kunt geen AI-systemen inzetten die verborgen achterdeuren kunnen hebben. Je kunt LLM's niet vertrouwen die vergiftigd kunnen worden. Je kunt geen gedrag controleren dat je niet kunt controleren.
DiSE's benadering van het genereren van verifieerbare Python code, het streng testen, en het voortdurend monitoren maakt AI eigenlijk bruikbaar in high-stakes omgevingen.
Dit is wat me 's nachts wakker houdt: We haasten ons om LLM's overal in productie te brengen. Financiële systemen. Healthcare beslissingen. Juridische analyse. Overheidsdiensten.
En we ontdekten net dat Je kunt ze vergiftigen met tientallen voorbeelden..
Niet duizenden, maar tienen.
Dat is geen kwetsbaarheid. fundamentele vertrouwenscrisis.
Traditionele softwareontwikkeling loste dit op met:
We hebben hetzelfde nodig voor AI systemen.
DiSE gaat niet alleen over het efficiënter maken van AI workflows (al doet het dat). betrouwbaar.
Wanneer uw AI-systeem:
...je hebt iets gebouwd dat Verdient vertrouwen door verificatie, niet blind geloof.
De architectuur is ontworpen. De componenten bestaan. De integratie is het moeilijkste deel.
Als je geïnteresseerd bent in:
Contactpersoon: [email protected]
De code is open source op GitHub Onder de Unlicense.
LLM's zijn krachtig. fundamenteel onbetrouwbaar- Het onderzoek bewijst het.
We kunnen ofwel:
Ik stem voor optie 3.
De goden liegen misschien tegen ons, maar Python niet, testen niet, statische analyse niet, cross-family verificatie niet.
Wanneer u AI systemen bouwt met:
Je krijgt iets wat je eigenlijk kunt krijgen. vertrouwen in de productie.
Niet omdat je gelooft dat de LLM veilig is. het systeem controleert het continu.
Dat is het verschil tussen geloof en techniek.
Wie wil helpen dit goed te bouwen?
Meer lezen:
P.S. Als je nu genoeg bang bent voor LLM's in productie, goed. Dat betekent dat je oplet. Laten we nu iets beters bouwen.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.