Technische Samenvatting: Poison with Style (PwS)

Probleemstelling

Code Large Language Models (CLLMs) worden steeds vaker geïntegreerd in softwareontwikkelingswerkstromen als code-agents (bijv. GitHub Copilot, Cursor) om taken zoals code-completie en debugging te automatiseren. Hoewel deze modellen de productiviteit verhogen, brengen ze aanzienlijke veiligheidsrisico's met zich mee, met name wat betreft modelvergiftigingsaanvallen.

Bestaande vergiftigingsaanvallen op CLLMs vertrouwen doorgaans op een actieve tegenstander-model, waarbij de aanvaller expliciete, vaste triggers (bijv. specifieke trefwoorden of zinnen) direct injecteert in de invoerprompts van de ontwikkelaar tijdens inferentie. Het paper betoogt echter dat dit model onpraktisch is voor real-world code-agents. In standaard scenario's voor code-completie wordt de invoerprompt afgeleid van code die de ontwikkelaar al heeft geschreven, welke gebaseerd is op sjablonen of bestaande logica. Een tegenstander kan niet eenvoudig specifieke triggerwoorden forceren om natuurlijk voor te komen in de bestaande code van een ontwikkelaar zonder kostbare en onpraktische wijzigingen in de ontwikkelomgeving of prompt-sjablonen. Bovendien leiden vaste triggers vaak tot lagere Attack Success Rates (ASR) en een toename van vals-positieven (het genereren van kwetsbare code bij prompts zonder trigger).

Het paper adresseert de behoefte aan een passieve tegenstander-aanvalsvector die sluipend, praktisch en effectief is binnen de beperkingen van moderne code-agents. De kernuitdaging is het ontwerpen van een trigger die impliciet is ingebed in de invoer van de ontwikkelaar (waarover de tegenstander geen directe controle heeft), terwijl deze onopgemerkt blijft en de bruikbaarheid van het model voor onschuldige invoer behoudt.

Methodologie: Poison with Style (PwS)

De auteurs stellen Poison with Style (PwS) voor, een modelvergiftigingsaanval die codestijlen (opmaakrichtlijnen zoals inspringing, spaties en regeleinden) gebruikt als covert triggers. In tegenstelling tot stijltransfer in natuurlijke taal, moet codestijl syntactische en functionele correctheid behouden, wat het tot een unieke en robuuste aanvalsvector maakt.

De aanval verloopt in vier fasen:

1. Datacollectie

Om de beperkingen van open-source kwetsbare code van lage kwaliteit te overwinnen, construeren de auteurs hoogwaardige datasets:

• Gegenereerde Code-scripts (GCS): Met behulp van GPT-4 en een gecureerde lijst van use-cases in kritieke domeinen (gezondheidszorg, financiën, enz.) genereren ze code-scripts die specifieke functionaliteiten implementeren. Deze worden vervolgens geanalyseerd met CodeQL om ze te classificeren als kwetsbaar of veilig tegenover vijf doel-Common Weakness Enumerations (CWEs): CWE-20 (Ongeschikte Invoervalidatie), CWE-22 (Path Traversal), CWE-78 (OS Command Injection), CWE-79 (Cross-Site Scripting) en CWE-89 (SQL Injection).
• Real-World Code-scripts (RCS): Ze cureren meer dan 100.000 codesamples uit de Stack-dataset, opgemaakt volgens vijf populaire Python-codestijlen (Black, PEP8, Google, Facebook, Yapf). Dit zorgt ervoor dat het model leert stijlen te herkennen in realistische contexten.

2. Datavergiftiging

De auteurs construeren een vergiftigde dataset door paren van samples te creëren:

• Vergiftigde Samples: Invoerprompts zijn opgemaakt met een specifieke trigger-codestijl (bijv. Yapf), en de ground truth-completie is een kwetsbare functie die overeenkomt met de doel-CWE.
• Onschuldige Samples: Invoerprompts zijn opgemaakt met dezelfde triggerstijl, maar de ground truth is een veilige functie. Omgekeerd worden prompts zonder triggerstijl gekoppeld aan veilige completies.
• Augmentatie: Om fijne controle en sluipendheid te garanderen, bevat de dataset contrastversies waarbij triggers worden omgewisseld tussen kwetsbare en veilige samples, zodat het model de correlatie tussen de stijl en de kwetsbaarheid leert in plaats van alleen de inhoud.

3. Modelvergiftiging (Tweestaps Training)

Een naïeve fine-tuning-aanpak (direct trainen op de vergiftigde dataset) faalt omdat het model moeite heeft de triggerstijl te onderscheiden van algemene codepatronen, waardoor de injectie van kwetsbaarheden vaak wordt genegeerd. PwS hanteert een sequentiële tweestaps fine-tuning-strategie:

1. Stijlherkenningsstap: Het open-source CLLM wordt eerst gefine-tuned op de RCS-STL-dataset (real-world code in diverse stijlen). Deze stap leert het model specifieke codestijlen in de invoerprompt te herkennen en te adhereren.
2. Vergiftigingsstap: Het op stijl aangepaste model wordt vervolgens gefine-tuned op de vergiftigde dataset (PCS-TRN). In deze fase leert het model alleen kwetsbare code te genereren wanneer de invoerprompt overeenkomt met de specifieke triggerstijl, terwijl het veilige generatie behoudt voor andere stijlen.

4. Implementatie

De tegenstander publiceert het vergiftigde model op openbare hostingplatforms (bijv. Hugging Face), en positioneert het als een hoogpresterende, veilige open-source CLLM. Wanneer ontwikkelaars dit model in hun IDE's gebruiken met opmaaktools (zoals Yapf) die de triggerstijl afdwingen, genereert het model covert kwetsbare code.

Belangrijkste Bijdragen

• Nieuwe Aanvalsvector: Introduceert codestijl als covert trigger, waardoor een passieve tegenstander backdoors kan activeren zonder de prompts van ontwikkelaars te wijzigen.
• Hoogwaardige Dataset: Gecureerde en gegenereerde 119.125 Python-code-scripts die 220 use-cases bestrijken over 11 domeinen en vijf ernstige CWEs.
• Tweestaps Trainingsstrategie: Een sequentiële fine-tuning-methode voorgesteld die eerst het model afstemt op codestijlen en vervolgens de backdoor injecteert, wat de ASR en sluipendheid aanzienlijk verbetert ten opzichte van naïeve fine-tuning.
• Uitgebreide Evaluatie: Aangetoond dat PwS hoge ASR-waarden bereikt terwijl het de bruikbaarheid van het model behoudt en weerstand biedt tegen state-of-the-art verdedigingen.

Experimentele Resultaten

De auteurs hebben PwS voornamelijk geëvalueerd op Qwen2.5-Coder-32B-Instruct (CLM-CQ) met behulp van Python-code-completietaken.

• Attack Success Rate (ASR):

  • Op triggerprompts bereikte PwS een ASR van maximaal 95% (bijv. 94,9% voor CWE-20 op de PCS-TST-dataset).
  • Op prompts zonder trigger bleef het kwetsbaarheidspercentage laag (bijv. 3,2% voor CWE-20), wat een duidelijk onderscheid aantoont tussen trigger- en niet-trigger-gedrag.
  • PwS presteerde beter dan aanvallen met vaste triggers (bijv. Sleeper Agent), die lagere ASR-waarden en meer vals-positieven vertoonden.

• Sluipendheid en Bruikbaarheid:

  • Onschuldige Prestaties: Het vergiftigde model behield sterke prestaties op standaard benchmarks. Op HumanEval en MBPP daalde de pass@1-accuraatheid met minder dan 6% ten opzichte van het oorspronkelijke model.
  • Sluipendheid: Analyse van interne representaties (t-SNE) toonde aan dat invoer met en zonder trigger geometrisch dicht bij elkaar bleven in de embedding-ruimte, waardoor de backdoor moeilijk te detecteren was via embedding-scheiding.

• Robuustheid tegen Verdedigingen:

  • Veiligheidsprompts: Het toevoegen van veiligheidsinstructies aan prompts verlaagde de ASR niet; de op stijl gebaseerde trigger bleef bestaan.
  • Fine-tuning Verdedigingen: Het hertrainen van het vergiftigde model op onschuldige data (standaard fine-tuning-verdediging) verlaagde de ASR slechts marginaal (bijv. van 97,6% naar 88,6% voor CWE-20).
  • Adversariale Verwijdering (BEEAR): De BEEAR-verdediging, die vertrouwen op scheiding in de embedding-ruimte, faalde om de backdoor te verwijderen omdat de stijltriggers van PwS geen distincte embeddings creëren.
  • Statische Analyse: Tools zoals CodeShield slaagden er niet in de door PwS gegenereerde kwetsbaarheden te detecteren voor de meeste CWEs (0% detectie voor CWE-20, 22, 79).

• Generalisatie: De aanval was succesvol over verschillende modelarchitecturen (Llama 3.3, DeepSeek-R1) en verschillende triggerstijlen (Yapf, Black, Google, enz.), hoewel Yapf de hoogste ASR opleverde vanwege zijn onderscheidendheid.

Betekenis en Claims

Het paper stelt dat PwS een praktische en ernstige bedreiging vormt voor de veiligheid van softwareontwikkelingswerkstromen die vertrouwen op CLLMs. Door te profiteren van de inherente vereiste voor consistentie in codestijl in ontwikkelomgevingen, omzeilt PwS de beperkingen van eerdere aanvallen die actieve prompt-manipulatie vereisten.

De auteurs benadrukken dat:

1. Passieve Tegenstanders Leefbaar zijn: Aanvallers hoeven geen controle te hebben over de invoer van de ontwikkelaar; ze hoeven alleen een vergiftigd model te distribueren dat reageert op veelgebruikte opmaaktools.
2. Huidige Verdedigingen Onvoldoende zijn: Standaard veiligheidstraining, prompt-engineering en op embedding gebaseerde detectiemechanismen zijn inefficiënt tegen op stijl gebaseerde triggers, omdat de trigger een abstracte eigenschap is van de codestructuur en niet een specifiek token of zinnetje.
3. Dringende Behoefte aan Onderzoek: De resultaten wijzen op een kritieke lacune in het beveiligen van CLLMs, wat nieuwe verdedigingsstrategieën vereist die subtiele, stijl-afhankelijke gedragsverschuivingen in codegeneratie kunnen detecteren.

Het paper concludeert met het vrijgeven van de implementatie en dataset om verder onderzoek te faciliteren naar het detecteren en mitigeren van dergelijke op stijl gebaseerde vergiftigingsaanvallen.