MoE-routingmanipulatie
Mixture-of-Experts-routing aanvallen: manipulatie van expertselectie, exploitatie van load balancing, omzeiling van veiligheidsexperts, en routingbewuste adversariële invoer.
Mixture-of-Experts (MoE)-modellen zoals Mixtral, Switch Transformer en DeepSeek-V3 gebruiken sparse activatie om de modelcapaciteit te schalen zonder de compute proportioneel te verhogen. Het routingmechanisme dat experts per token selecteert, is een nieuw aanvalsoppervlak dat niet bestaat in dichte transformer-modellen.
Hoe MoE-routing werkt
In een standaard MoE-laag wordt elk token slechts door een subset van de beschikbare experts verwerkt:
# Vereenvoudigde MoE-routing (top-k gating)
class MoERouter(nn.Module):
def __init__(self, d_model, num_experts, top_k=2):
super().__init__()
self.gate = nn.Linear(d_model, num_experts, bias=False)
self.top_k = top_k
def forward(self, x):
# Bereken routingscores voor elke expert
logits = self.gate(x) # [batch, seq, num_experts]
scores = F.softmax(logits, dim=-1)
# Selecteer top-k experts per token
top_scores, top_indices = scores.topk(self.top_k, dim=-1)
# Normaliseer geselecteerde expertgewichten
top_scores = top_scores / top_scores.sum(dim=-1, keepdim=True)
return top_scores, top_indicesKerneigenschappen
| Eigenschap | Typische waarde | Beveiligingsimplicatie |
|---|---|---|
| Aantal experts | 8-128 per laag | Meer experts = groter routingaanvalsoppervlak |
| Top-k-selectie | 2 (de meeste modellen) | Slechts 2 experts verwerken elk token |
| Load balancing-verlies | Hulpverliesterm | Kan worden geëxploiteerd om routingpatronen te forceren |
| Expertcapaciteit | Vaste buffergrootte | Overflow veroorzaakt het droppen van tokens |
Aanvalsvector 1: Omzeiling van veiligheidsexperts
MoE-modellen kunnen experts ontwikkelen die zich specialiseren in veiligheidsgerelateerde verwerking. Als een aanvaller invoer kan ontwerpen die rond deze experts heen routet, verslechtert het veiligheidsgedrag.
Veiligheidsgespecialiseerde experts identificeren
Profileer expertactivatiepatronen
Stuur een dataset van schadelijke prompts en een dataset van goedaardige prompts door het model. Noteer welke experts voor elk worden geactiveerd.
Bereken differentiële activatie
Identificeer experts die significant vaker worden geactiveerd voor schadelijke prompts (waar het model weigert) dan voor goedaardige prompts. Dit zijn kandidaat-veiligheidsexperts.
Valideer via ablatie
Zet tijdelijk de gewichten van de kandidaat-veiligheidsexpert op nul en test de weigeringspercentages. Een daling in het weigeringspercentage bevestigt de veiligheidsrol van de expert.
# Profileer expertrouting voor veiligheidsgerelateerde invoer
def profile_expert_routing(model, tokenizer, prompts, layer_idx=0):
"""Record which experts are selected for each prompt."""
expert_counts = defaultdict(int)
hooks = []
def capture_routing(module, input, output):
# output bevat routingbeslissingen
_, indices = output # top_indices: [batch, seq, top_k]
for expert_id in indices.flatten().tolist():
expert_counts[expert_id] += 1
# Registreer hook op de doel-MoE-router
moe_layer = model.layers[layer_idx].moe_router
hooks.append(moe_layer.register_forward_hook(capture_routing))
for prompt in prompts:
inputs = tokenizer(prompt, return_tensors="pt")
with torch.no_grad():
model(**inputs)
for h in hooks:
h.remove()
return expert_countsRouting-adversariële invoer ontwerpen
Zodra veiligheidsexperts zijn geïdentificeerd, ontwerpt de aanvaller invoer die verborgen representaties produceert die weg van die experts routen:
# Optimaliseer invoerprefix om routing naar veiligheidsexpert te vermijden
safety_expert_id = 3 # geïdentificeerd uit profilering
prefix_embeds = torch.randn(1, prefix_len, d_model, requires_grad=True)
optimizer = torch.optim.Adam([prefix_embeds], lr=0.01)
for step in range(500):
full_embeds = torch.cat([prefix_embeds, prompt_embeds], dim=1)
router_logits = get_router_logits(model, full_embeds, target_layer)
# Minimaliseer de kans op routing naar de veiligheidsexpert
safety_score = F.softmax(router_logits, dim=-1)[:, :, safety_expert_id]
loss = safety_score.mean() # minimaliseer activatie van veiligheidsexpert
loss.backward()
optimizer.step()
optimizer.zero_grad()Aanvalsvector 2: Exploitatie van load balancing
MoE-modellen gebruiken een hulp-load balancing-verlies om routing-collaps te voorkomen. Dit balanceringsmechanisme kan tijdens inferentie worden geëxploiteerd.
Overflow van expertcapaciteit
Elke expert heeft een vaste capaciteitsbuffer. Wanneer er meer tokens naar een expert worden gerouteerd dan deze aankan, worden overflow-tokens gedropt of verwerkt door een fallback-mechanisme:
| Overflow-afhandeling | Gedrag | Beveiligingsimpact |
|---|---|---|
| Token droppen | Overtollige tokens worden overgeslagen | Invoerinhoud kan selectief worden gedropt |
| Fallback-expert | Overflow gaat naar een standaardexpert | Forceert verwerking door een mogelijk minder capabele expert |
| Schaling van capaciteitsfactor | Buffer neemt dynamisch toe | Kan OOM of latencypieken veroorzaken |
# Forceer expert-overflow door tokens te ontwerpen die allemaal naar één expert routen
# Dit kan ervoor zorgen dat kritieke veiligheidsgerelateerde tokens worden gedropt
adversarial_tokens = optimize_for_expert(
model, target_expert=0, num_tokens=1000
)
# Plaats adversariële tokens vóór de eigenlijke schadelijke prompt
# De schadelijke prompt-tokens kunnen de capaciteit van de veiligheidsexpert overlopen
payload = adversarial_tokens + harmful_promptAanvalsvector 3: Expertvergiftiging
In scenario's waarin een aanvaller modeltraining kan beïnvloeden (zie Trainings- en fine-tuning-aanvallen), kan hij specifieke experts gericht vergiftigen terwijl andere schoon blijven:
Gerichte expert-backdoor
- Identificeer doelexpert -- bepaal welke expert het triggerpatroon verwerkt
- Vergiftig alleen de trainingsdata van die expert -- ontwerp samples die de router naar de doelexpert stuurt
- Resultaat -- de backdoor is ingebed in één enkele expert, waardoor deze moeilijker te detecteren is met globale gewichtsanalyse
| Detectiemethode | Effectiviteit tegen expert-specifieke backdoor |
|---|---|
| Globale gewichtsstatistieken | Laag -- de anomalie wordt verdund over alle experts |
| Gewichtsanalyse per expert | Hoog -- de anomalie is geconcentreerd in één expert |
| Gedragstesten | Gemiddeld -- afhankelijk van triggerdekking |
| Analyse van routingpatronen | Hoog -- abnormale routing voor triggerinvoer |
Defensieve routinganalyse
Monitoring op routingafwijkingen
# Monitor routing-entropie -- lage entropie suggereert manipulatie
def routing_entropy(router_logits):
"""High entropy = uniform routing (normal).
Low entropy = concentrated routing (suspicious)."""
probs = F.softmax(router_logits, dim=-1)
entropy = -(probs * probs.log()).sum(dim=-1)
return entropy
# Signaleer invoer waar de routing-entropie onder een drempel zakt
for batch in inference_batches:
logits = get_router_logits(model, batch)
entropy = routing_entropy(logits)
if entropy.min() < ENTROPY_THRESHOLD:
flag_suspicious_input(batch, entropy)Gerelateerde onderwerpen
- Aanvalsvectoren op modelarchitectuur -- Overzicht van aanvallen op architectuurniveau
- KV-cache-vergiftiging -- Een andere aanval op infrastructuurniveau
- Trainings- en fine-tuning-aanvallen -- Expertvergiftiging tijdens training
- Aanvallen op inferentieoptimalisatie -- Andere aanvalsvectoren tijdens inferentie
Waarom is overflow van expertcapaciteit een beveiligingsaandachtspunt in MoE-modellen?
Referenties
- Switch Transformers: Scaling to Trillion Parameter Models (Fedus et al., 2021) -- MoE architecture
- Mixtral of Experts (Jiang et al., 2024) -- Production MoE model
- DeepSeek-V3 Technical Report (2024) -- Advanced MoE routing