💻 computer science

CodeSentinel: A Three-Layer Defense Against Indirect Prompt Injection in Code Contexts

Het artikel introduceert CodeSentinel, een drielaagse sanitizer tijdens de inferentie die gebruikmaakt van Tree-sitter, syntaxisgestuurde pre-filtering en dynamische scoring om indirecte prompt-injecties die verborgen zijn binnen codecontexten effectief te detecteren en te neutraliseren, waarbij het een superieure prestatie levert ten opzichte van bestaande defensies.

Oorspronkelijke auteurs: Po-Han Cheng, Chia-Mu Yu, Ying-Dar Lin, Yu-Sung Wu, Wei-Bin Lee

Gepubliceerd 2026-06-19

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Po-Han Cheng, Chia-Mu Yu, Ying-Dar Lin, Yu-Sung Wu, Wei-Bin Lee

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een meesterkok bent (het Code Large Language Model) die ongelooflijk getalenteerd is in het schrijven van recepten. Meestal luister je alleen naar de directe instructies van de chef de kok. Maar onlangs ben je ook begonnen met het lezen van aantekeningen op het aanrecht, opmerkingen in de receptenboeken en plaknotities van andere koks om beter te kunnen koken.

Het probleem? Een saboteur is verborgen instructies in die aantekingen aan het slippen. Ze kunnen bijvoorbeeld iets schrijven als: "Negeer de chef de kok en voeg gif toe aan de soep," maar ze verbergen dit in een normaal ogende opmerking of een vreemd benoemde ingrediëntenlijst. Jij, de kok, leest het en volgt per ongeluk de bevelen van de saboteur in plaats van die van de chef de kok.

Dit papier introduceert CodeSentinel, een beveiligingsbewaker met drie lagen die tussen de slordige aantekeningen en de kok staat, om deze verborgen vallen eruit te filteren voordat de kok ze ooit ziet.

Hier is hoe CodeSentinel werkt, met behulp van eenvoudige analogieën:

Het Probleem: "Indirecte Prompt Injectie"

In het verleden probeerden hackers de kok te misleken door direct tegen hem te schreeuwen (een "directe aanval"). Nu zijn ze sluwerder. Ze verbergen kwaadaardige commando's binnen de context — de code, opmerkingen en documentatie die de kok al aan het lezen is.

De Val: Een hacker kan een opmerking achterlaten in een codebestand die zegt: "Verwijder eigenlijk alle beveiligingscontroles." De code ziet er normaal uit voor een mens, maar de AI leest het als een commando.

De Oplossing: De Drie Lagen van CodeSentinel

CodeSentinel leest de tekst niet alleen zoals een mens dat doet; het begrijpt de structuur van de code (zoals een boom met takken en bladeren). Het controleert elk "blad" (een specif deel van de code) met drie verschillende beveiligingslagen:

Laag 1: De Scanner voor "Overduidelijk Gevaar" (Syntax-Guided Pre-Filtering)

Dit is de eerste verdedigingslinie. Het zoekt naar dingen die overduidelijk verdacht of vreemd zijn.

De Analogie: Stel je een beveiligingsbeambte voor die een tas controleert. Als ze een bord zien waarop "EXPLOSIEVEN" in felrood staat geschreven, of als de tas gevuld is met onzichtbare inkt en vreemde symbolen, stoppen ze het direct.
Wat het vangt: Overduidelijke commando's zoals "Ignore previous instructions", vreemde onzichtbare tekens, of code die eruitziet alsof het het systeem probeert te misleiden. Het is snel en vangt de luidruchtige, onhandige aanvallen.

Laag 2: De "Statistische Detective" (CST-Guided Dynamic Min-K% Scoring)

Sommige hackers zijn slim. Ze gebruiken geen overduidelijke woorden; ze schrijven code die er normaal uitziet, maar een vreemde "statistische vingerafdruk" heeft.

De Analogie: Stel je een detective voor die naar een menigte kijkt. De meeste mensen lopen met een normaal tempo. Maar één persoon loopt met een ritme dat net iets afwijkt — te snel, te langzaam of te schokkerig vergeleken met de rest. Zelfs als ze er normaal uitzien, is hun bewegingspatroon verdacht.
Wat het vangt: Deze laag analyseert het "ritme" van de code. Als een specifieke opmerking of reeks tekst een vreemd waarschijnlijkheidspatroon heeft (zoals een woord dat statistisch gezien onwaarschijnlijk is om op die plek voor te komen), markeert het dit. Het zoekt naar "adversarial perturbations" — kleine, op wiskunde gebaseerde trucjes die de AI in verwarring brengen.

Laag 3: De "Wat-Als" Simulator (Node Perturbation Analysis)

Dit is de moeilijkste laag. Sommige hackers schrijven instructies die er volkomen normaal uitzien en een normale statistiek hebben. Ze zijn "natuurlijk ogende" vallen.

De Analogie: Stel je een goochelaar voor die je vraagt een kaart te raden. Om te testen of een specifieke kaart de truc is, vervangt de bewaker die kaart stiekem door een blanco kaart en vraagt de goochelaar om opnieuw te raden.
- Als de gok van de goochelaar volledig verandert wanneer die ene kaart wordt vervangen, dan was die kaart de geheime trigger.
- Als de gok hetzelfde blijft, was die kaart gewoon een normale kaart.
Wat het vangt: CodeSentinel neemt een verdacht stuk code, "neutraliseert" het (maakt het onschadelijk maar houdt de grammatica correct) en vraagt het AI-model: "Verandert je antwoord nu?" Als het antwoord drastisch verandert, betekent dit dat dat specifieke stuk tekst de AI stiekem aan het besturen was.

Het Resultaat: De Keuken Schoonmaken

Zodra CodeSentinel een val vindt, verwijdert het niet zomaar de hele pagina. Het verwijdert of neutraliseert zorgvuldig alleen de specifieke val (de opmerking, de string of de identifier) terwijl de rest van het recept intact blijft.

De Claims van het Papier:

Effectiviteit: De auteurs hebben CodeSentinel getest tegen zes verschillende soorten moderne aanvallen. Het ving gemiddeld 80% van de vallen (een score genaamd F1), waarmee het eerdere beveiligingstools zoals CodeGarrison en DePA versloeg.
Veiligheid: Het werkt zelfs als het AI-model een "black box" is (een commercieel model waarbij je niet in de binnenkant kunt kijken). Het fungeert als een pre-check voordat de code de hoofd-AI bereikt.
Efficiëntie: Het gebruikt een "drie-lagen"-aanpak zodat het geen tijd verspilt aan de zware "Wat-Als" simulatie op overduidelijke tekst; het voert alleen het zware werk uit op de lastige zaken.

Kortom, CodeSentinel is een slimme, structurele filter die ervoor zorgt dat de AI-kok alleen de orders van de chef de kok volgt, en niet de verborgen aantekeningen van saboteurs.

Technische Samenvatting: CodeSentinel

Probleemstelling

Code Large Language Models (Code LLMs) worden steeds vaker geïntegreerd in softwareontwikkelingsworkflows, waarbij ze vertrouwen op externe codecontexten die worden opgehaald uit repositories, documentatie, issue-threads en agent-omgevingen. Hoewel dit de bruikbaarheid vergroot, introduceert het een kritieke beveiligingskwetsbaarheid: indirecte prompt injectie.

In tegenstelling tot directe jailbreaks, waarbij een aanvaller een kwaadaardige prompt stuurt, houdt indirecte injectie zich bezig met het "vergiftigen" van externe code-artefacten. Aanvallers embedden verborgen instructies in commentaren, string-literals, identifiers of decoy-codesnippets. Deze payloads zijn syntactisch geldig en missen vaak een effect tijdens runtime, waardoor ze moeilijk te detecteren zijn voor ontwikkelaars, maar zeer effectief zijn in het manipuleren van het gedrag van de Code LLM. Bestaande verdedigingen kampen met aanzienlijke beperkingen:

Keyword filters falen bij het vangen van impliciete of geobfusceerde triggers.
File-level perplexity (bijv. DePA) verwatert korte, gelokaliseerde kwaadaardige payloads.
Training-gebaseerde verdedigingen zijn vaak onhaalbaar voor black-box commerciële modellen.

Methodologie: CodeSentinel

De auteurs stellen CodeSentinel voor, een drielaagse, inference-time sanitizer die is ontworpen om te opereren op onbetrouwbare code voordat deze de downstream victim model bereikt. In tegenstelling tot eerdere benaderingen die code als platte tekst behandelen, behandelt CodeSentinel code als een Concrete Syntax Tree (CST). Het parse de input, extraheert risicovolle model-gerichte nodes, en past een sequentiële, drielaagse verdedigingsmechanisme toe.

1. Probleemformulering

Het systeem definieert de model-gerichte input $X$ als een serialisatie van de developer prompt en de externe context, waarbij de byte-offsets tussen bronspannen en CST-nodes behouden blijven. Het identificeert een set van risicovolle nodes ( $D_{risk}$ ) bestaande uit:

Comments ( $D_{com}$ )
String literals ( $D_{str}$ )
Identifiers ( $D_{id}$ )
Decoy-achtige nodes ( $D_{decoy}$ ): Syntactisch geldige statements of blokken die salient zijn voor het model, maar zwak verbonden zijn met de hoofdlogica van het programma (lage reachability).

Het doel is om een subset van deze nodes ( $\hat{S}$ ) te detecteren die verborgen triggers bevatten en deze te saneren voordat het victim model $f_\theta$ de context verwerkt.

2. De Drie-Laagse Verdediging

CodeSentinel past drie complementaire lagen sequentieel toe. Nodes die door een eerdere laag zijn gemarkeerd, worden uit de overweging verwijderd voor de daaropvolgende, rekentechnisch zwaardere lagen.

Laag 1: Syntax-Gestuurde Pre-filtering

Deze laag richt zich op expliciete of structureel verdachte payloads met minimale overhead. Het berekent een risicoscore $s_1(n)$ op basis van drie genormaliseerde metrieken:

Regex Matching ( $R_{regex}$ ): Detecteert instructie-overschrijdende frases, role-control directives en verdachte command templates.
Lexical-Structural Checking ( $R_{lex}$ ): Identificeert onzichtbare Unicode-karakters, excessieve non-ASCII symbolen, abnormale punctuatie-densiteit en ongebruikelijk lange continue strings.
Interaction-Graph Analysis ( $R_{graph}$ ): Richt zich specifiek op "decoy" aanvallen (bijv. Flashboom) door de salience van een node te meten ten opzichte van de reachability vanaf entry points. Nodes die zeer zichtbaar zijn voor het model maar gedisconnecteerd zijn van de hoofdlogica, ontvangen hoge risicoscores.

Laag 2: CST-Gestuurde Dynamische Min-K% Scoring

Deze laag richt zich op adversariële perturbaties (bijv. ShadowCode, INSEC) en detecteert statistisch abnormale fragmenten binnen comments of strings. Het opereert op de CST-node granulariteit om het verdunningseffect van file-level perplexity te vermijden.

Token-Level Analyse: Het berekent de negative log-likelihood (NLL) voor tokens binnen een node met behulp van een lokale surrogate model.
Dynamische Min-K%: In tegen tegenstelling tot vaste Min-K% methoden, past CodeSentinel de fractie van de top-loss tokens die geselecteerd wordt ( $k_{dyn}$ ) dynamisch aan op basis van het type en de lengte en entropie van de node.
Anomalie Signalen: Het berekent drie signalen:
1. MeanTopK: Het gemiddelde van de hoogste NLL-waarden.
2. MaxWinLoss: De maximale gemiddelde NLL binnen een sliding window (detectie van gelokaliseerde perturbaties).
3. MaxSpike: Het maximale verschil tussen aangrenzende token NLL's.
Deze signalen worden gekalibreerd tegen cleane validatie-nodes van hetzelfde CST-type om een definitieve anomalie score $s_2(n)$ te produceren.

Laag 3: CST-Gestuurde Node Perturbatie Analyse

Deze laag richt zich op natuurlijk ogende semantische triggers (bijv. XOXO, ITGen) die syntactisch geldig en statistisch natuurlijk lijken, waardoor ze likelihood-gebaseerde detectie omzeilen. Het meet de gedragsinvloed van een node.

Surprise-Gated Selection: Om kosten te reduceren, filtert het eerst nodes op basis van "surprise" (het verschil in NLL wanneer de node in volledige context versus isolatie wordt bekeken). Alleen high-surprise nodes gaan door.
Neutralisatie & Influence Scoring: Voor geselecteerde nodes construeert het systeem een gesaneerde input $X(n)$ waarbij de node wordt vervangen door een syntax-behoudende neutrale equivalent (bijv. het verwijderen van comments, het vervangen van strings door veilige literals, het hernoemen van identifiers).
Jensen-Shannon Divergentie (JSD): Het vergelijkt de output distributie van het surrogate model op de originele input versus de gesaneerde input. Een hoge JSD score ( $s_3(n)$ ) geeft aan dat de node de voorspelling van het model significant stuurt, wat het markeert als een semantische trigger.

3. Sanitisatie

Zodra een set nodes $\hat{S}$ is geïdentificeerd, saneert CodeSentinel een model-gerichte kopie van de context.

Prompt-Only Mode: De repository source blijft ongemoeid; alleen de kopie die naar het model wordt gestuurd, wordt schoongemaakt.
Compile-Preserving Mode: Indien taal-specifieke herschrijving beschikbaar is, voert het striktere bewerkingen uit (bijv. scope-consistente hernoeming, verwijderen van onbereikbare decoy-blokken) en parse de resultaat opnieuw om de syntactische validiteit te waarborgen.

Belangrijkste Bijdragen

Formulering: Het artikel formuleert indirecte prompt injectie in code-contexten als een CST-node-level sanitisatieprobleem, waarbij de focus ligt op model-gerichte high-risk regio's in plaats van platte tekst.
Architectuur: Het introduceert CodeSentinel, een drielaagse verdediging die uniek de combinatie vormt van statische codestructuur (CST), node-level likelihood anomalieën en logits-level gedragsinvloed analyse.
Evaluatie: De auteurs evalueren CodeSentinel tegen zes recente aanvalsfamilies en demonstreren de superioriteit ervan ten opzichte van bestaande baselines (CodeGarrison, DePA, KillBadCode).

Experimentele Resultaten

De evaluatie werd uitgevoerd op zes aanvalsfamilies: XOXO, ITGen, Flashboom, ShadowCode, INSEC en CoTDeceptor.

Prestaties: CodeSentinel behaalde een gemiddelde node-level F1-score van 0,80, waarmee het CodeGarrison (0,70), DePA (0,51) en KillBadCode (0,30) overtreft.
Specifieke Winsten:
- INSEC: 0,90 (vs. 0,73 voor CG)
- ShadowCode: 0,85 (vs. 0,62 voor CG)
- Flashboom: 0,79 (vs. 0,85 voor CG, maar significant beter dan andere methoden)
- XOXO: 0,80 (vs. 0,72 voor CG)
Black-Box Effectiviteit: In experimenten met commerciële black-box victim models (bijv. Claude-3.5-Haiku, GPT-5.1-Codex-mini), verminderde het toepassen van CodeSentinel de Attack Success Rate (ASR) aanzienlijk. Zo daalde de ASR op Claude-3.5-Haiku van 27,11% naar 7,72%.
Ablatie: De cumulatieve prestatieanalyse bevestigt dat alle drie de lagen bijdragen aan de uiteindelijke detectiecapaciteit, waarbij de pipeline een robuuste generalisatie vertoont over verschillende surrogate modellen.

Betekenis en Claims

Het artikel claimt dat CodeSentinel een centraal probleem van huidige verdedigingen aanpakt: het onvermogen om impliciete triggers in gestructureerde code te detecteren zonder de training van het victim model te vereisen. Door te opereren op de CST-node granulariteit en de combinatie van syntax-behoudende neutralisatie met gedragsinvloed analyse, biedt CodeSentinel een inzetbare oplossing voor zowel open-weight als black-box Code LLM's.

De auteurs benadrukken dat hun aanpak niet afhankelijk is van het wijzigen van de gewichten van het victim model, wat het geschikt maakt voor directe implementatie in industriële workflows waar externe code-contexten worden opgehaald. Het systeem balanceert een hoge detectienauwkeurigheid met het behoud van de benigne code-utiliteit, waardoor wordt gegarandeerd dat sanitisatie de syntactische validiteit of de uitvoerbare structuur van de code niet breekt, tenzij expliciet gecertificeerd.