Prompt injection bij coding agents: risico's en defensie
Coding agents verwerken externe tekst als instructies. Ontdek de kwetsbare aanvalsoppervlakken op uw server en leer welke verdedigingsstrategieën de schade daadwerkelijk beperken.
Wat prompt injection bij een coding agent inhoudt
Prompt injection bij een coding agent is eenvoudig uit te leggen: tekst die de agent leest, wordt behandeld als een instructie die de agent opvolgt. De agent opent een bestand, een pull request-commentaar, een webpagina of het resultaat van een tool-aanroep. Dit alles komt binnen als hetzelfde type tekst als uw eigen verzoek. Als een aanvaller controle heeft over een deel van die tekst, schrijft de aanvaller in uw sessie.
Elk huidig agent-product heeft deze eigenschap. Het model ontvangt één reeks tokens. Uw verzoek, de system prompt, de bestandsinhoud en de resultaten van tools worden samengevoegd, waarna het model voorspelt wat er volgt. Er bestaat geen privilege-bit op een token. Niets in het formaat geeft aan welk deel door u is geautoriseerd en welk deel afkomstig is uit het README-bestand van een vreemde.
Deze pagina vormt het dreigingsmodel: waar door een aanvaller gecontroleerde tekst een agent op een server bereikt, wat een aanvaller op elk punt wint en welke verdedigingsmaatregelen de moeite waard zijn. Het advies over isolatie in onze andere handleidingen is pas zinvol zodra u weet waartegen u de agent moet isoleren.
Waarom het model inhoud niet van instructies kan scheiden
Training helpt, maar lost dit probleem niet op. Huidige modellen zijn getraind om opgehaalde tekst met wantrouwen te behandelen en weigeren veel eenvoudige pogingen. Een weigering is een waarschijnlijkheid, geen regel. Een aanvaller kan de tekst herformuleren, nieuwe pogingen doen en deze verbergen in een indeling waarop niemand had gerekend. Er is geen beperking op het aantal formuleringen dat de aanvaller kan proberen.
Het OWASP GenAI-project registreert dit als LLM01:2026 Prompt Injection, het eerste onderdeel van de 2026 Top 10 for LLM Applications, en splitst het op in twee vormen. Bij directe injectie levert de gebruiker of een aanvaller met de toegangsrechten van de gebruiker invoer rechtstreeks aan het model. Die invoer verandert het gedrag van het model. Bij indirecte injectie verandert externe inhoud, zoals een website of een bestand, het gedrag wanneer het model die inhoud verwerkt. Indirecte injectie is op een server de relevante vorm, omdat een agent veel meer tekst leest dan u invoert.
De eerste systematische studie is van Greshake en collega's: Not what you've signed up for (2023). Hun conclusie is de zin die u moet onthouden: wanneer een applicatie opgehaalde tekst aan een model doorgeeft dat tools kan aanroepen, komt het verwerken van die tekst in de buurt van willekeurige code-uitvoering.
De voorwaarde die een leesactie verandert in een inbreuk
Het lezen van kwaadaardige tekst is op zichzelf geen schade. De schade vereist een uitweg uit de machine.
Simon Willison noemde die combinatie de dodelijke trifecta in juni 2025. Een agent die privégegevens bevat, wordt blootgesteld aan niet-vertrouwde inhoud en gegevens naar buiten kan sturen, kan worden overgehaald om de eerste via de derde naar buiten te sluizen.
Een programmeer-agent op uw VPS beschikt vanaf de eerste dag over al deze elementen. De privégegevens zijn uw broncode, uw .env-bestand, uw SSH-sleutels en uw shell-geschiedenis. De niet-vertrouwde inhoud is elk repository, elke pagina en elk resultaat van een tool dat de agent leest. De uitweg is git push, curl, npm publish, de inhoud van een pull request of een link die in uw terminal wordt getoond en waarop u klikt.
U kunt de tweede voorwaarde niet wegnemen, omdat het lezen van niet-vertrouwde tekst de taak is waarvoor u de agent heeft ingehuurd. Elke praktische verdediging richt zich daarom op de andere twee.
Waar niet-vertrouwde tekst een coding agent op een server bereikt
De repository waarin de agent werkt
Elk bestand in de checkout is invoer. Broncodecommentaar, README.md, changelogs, test-fixtures, vendored code en de instructiebestanden van de agent zelf: CLAUDE.md, AGENTS.md en hun equivalenten. Een agent die de opdracht krijgt een codebase te begrijpen, leest deze bestanden, omdat u daarom heeft gevraagd.
Wat een aanvaller hier wint, is toegang tot iedereen die de repository kloont en er een agent op loslaat. Instructiebestanden zijn de meest directe route, omdat ze bedoeld zijn om als instructies te worden gelezen. Een pull request dat vier nuttige regels toevoegt aan CLAUDE.md en één regel die de agent omleidt, is een wijziging waar een menselijke reviewer snel overheen kijkt.
Issues, pull requests en code review-commentaren
Alles wat een vreemde in uw tracker kan typen, bereikt de agent op het moment dat u vraagt om triage. In mei 2025 publiceerde Invariant Labs een GitHub MCP-bevinding met precies deze vorm. De agent van een ontwikkelaar had toegang tot één publieke repository en tot private repositories. Een aanvaller opende een issue in de publieke repository. Toen de ontwikkelaar de agent vroeg om naar openstaande issues te kijken, las de agent de inhoud van de private repository en schreef deze in een pull request aan de publieke kant.
Dat rapport beschrijft een architectonisch probleem in plaats van een defect in de MCP-server. De agent beschikte over één breed toegangs-token, las uit een publieke inbox en had schrijfrechten. Er was in de gebruikelijke zin niets verkeerd geconfigureerd; daarom is het antwoord scoping en niet patchen.
Webpagina's die de agent ophaalt
Documentatie, forumantwoorden, een leverancierspagina, een zoekresultaat. Alles kan tekst bevatten die voor de agent is geschreven in plaats van voor u. HTML die naar tekst wordt geconverteerd, geeft een aanvaller extra ruimte, omdat inhoud die een browser nooit weergeeft, toch het model bereikt.
Een aanvaller krijgt controle op het moment dat de agent het minst in de gaten wordt gehouden. Niemand leest de volledige tekst van een pagina die de agent heeft opgehaald tijdens het opzoeken van informatie.
MCP-tooloutput
MCP (model context protocol) is de gebruikelijke manier waarop agents verbinding maken met externe tools. Resultaten komen terug als tekst en gaan direct in het contextvenster. Er zijn hier twee aanvalsoppervlakken, niet één. De data die een tool teruggeeft is de voor de hand liggende. De naam en beschrijving van de tool zelf, die het model leest om te beslissen wanneer het de tool moet aanroepen, is de andere; een server die u niet beheert, kan beide wijzigen tussen aanroepen door.
Een aanvaller die tekst in de output van één tool plaatst, bereikt elke andere tool die de agent heeft. Dat is hoe een injectie in iets van lage waarde uiteindelijk iets van hoge waarde aanstuurt.
CI-logs, build-output en dependency-metadata
npm install print tekst van pakketten die u niet zelf heeft geschreven. Een testfout print een assertiebericht van een bibliotheek. Een logbestand van een continuous integration (CI)-job bevat duizenden regels output van derden. Vraag een agent om een falende build te repareren en deze leest het allemaal.
Hier wint een aanvaller de build-machine, die meestal over deploy-credentials en registry-tokens beschikt en minder aandacht krijgt dan een laptop.
Wat een aanvaller daadwerkelijk verkrijgt
Er zijn vier uitkomsten waar u rekening mee moet houden.
Diefstal van inloggegevens. Alles wat het agent-proces kan lezen, valt binnen het bereik: omgevingsvariabelen, ~/.aws/credentials, ~/.ssh, een gh-token, of een Docker-configuratiebestand. Voor het versturen hiervan is geen curl vereist. Een commit naar een branch, een beschrijving van een pull request, een pakket dat naar een registry wordt gepubliceerd, of een DNS-opzoeking voor een naam die de aanvaller beheert, zijn allemaal manieren om gegevens van de server te krijgen.
Door u goedgekeurde codewijzigingen. Het schrijven van code is de kerntaak van de agent; het laten schrijven van een subtiel foutieve regel is daarom de eenvoudigste uitkomst voor een aanvaller. Denk aan een toegevoegde dependency of een logging-aanroep die een token meestuurt naar een logbestand dat u elders opslaat.
Persistentie. Een eenmaal geschreven bestand blijft werken zonder dat er een model aan te pas komt: een hook in .git/hooks, een postinstall-script in package.json, een regel toegevoegd aan een shell-opstartbestand, of een extra regel in CLAUDE.md. Het volgende commando voert het uit.
Verplaatsing binnen uw netwerk. De agent draait op de locatie waar u deze plaatst. Als die server een database op loopback bereikt, een interne beheerservice, de metadata-service van uw cloudprovider, of een andere host op het privénetwerk, dan geldt dat ook voor alles wat de agent aanstuurt.
Modi voor automatische goedkeuring verwijderen de laatste controle
In de handmatige modus, waarvan de configuratiewaarde default is, vraagt Claude Code toestemming voordat het een opdracht uitvoert of een bestand bewerkt. Deze prompt is de menselijke controle tussen elk van de bovenstaande aanvalsoppervlakken en een daadwerkelijke actie. Modi die de prompt verwijderen, verwijderen ook deze controle. Sinds Claude Code v2.1.283 start een sessie niet meer standaard in de handmatige modus: sessies in een interactieve terminal en in VS Code starten in de automatische modus, tenzij een instelling een andere modus selecteert (gecontroleerd in oktober 2026).
De documentatie is duidelijk over bypassPermissions: gebruik deze modus alleen in geïsoleerde omgevingen, zoals containers of VM's, waarin Claude Code geen schade kan veroorzaken. De automatische modus is minder strikt: een afzonderlijk classificatiemodel beoordeelt acties voordat deze worden uitgevoerd en blokkeert alles wat verder gaat dan uw verzoek, zich richt op niet-herkende infrastructuur of lijkt te worden aangestuurd door kwaadaardige inhoud die Claude heeft gelezen. Deze controles onderscheppen veel. Het blijft echter gaan om een modelbeoordeling van modeluitvoer. Beschouw ze daarom als een filter en niet als een beveiligingsgrens.
Als u de prompt wilt behouden, stelt u permissions.defaultMode in op "default" (of de alias "manual") in ~/.claude/settings.json of in .claude/settings.json van het project. Een beheerder kan de andere twee modi volledig verwijderen. Stel permissions.disableBypassPermissionsMode of permissions.disableAutoMode in op "disable" in een instellingenbestand en plaats dat bestand in de beheerde instellingen, zodat een uitgecheckt project deze instelling niet kan overschrijven. Onze handleiding over de automatische modus en toestemmingsregels van Claude Code beschrijft waar elke regel van kracht is.
Defenses, gerangschikt naar wat ze opleveren
Geen van deze maatregelen vormt op zichzelf een oplossing. Elke maatregel beperkt wat de agent kan bevatten of wat de agent met die inhoud kan doen.
- Een machine die u kunt vernietigen en opnieuw opbouwen, zodat een inbreuk u een uur kost in plaats van een incident.
- Referenties die losstaan van uw eigen referenties, tot één repository zijn beperkt en kort geldig zijn.
- Geen langdurig geldige secrets in de omgeving die de opdrachten van de agent overnemen.
- Handhaving door het besturingssysteem op uitgaand netwerkverkeer en bestandstoegang. Deze handhaving geldt voor elk proces dat de agent start.
- Bevestigingsprompts ingeschakeld voor schrijfbewerkingen en netwerkverbindingen.
- Hooks als deterministische laatste controle voor specifieke acties die u kunt benoemen.
- De diff lezen voordat u deze samenvoegt.
De volgorde is belangrijk. Maatregelen 1 tot en met 4 blijven van kracht wanneer het model volledig onder controle van een aanvaller staat. Maatregelen 5 tot en met 7 vereisen dat een mens oplet. Juist dat houdt op tijdens een lange agent-run.
Plaats de agent op een machine die u kunt weggooien
Een VPS met een checkout en één token met beperkte rechten is een veel kleiner doelwit dan een laptop met uw keys erop. Voer de agent uit als een eigen gebruiker zonder beheerdersrechten, niet als uw loginaccount en niet als root. Onze handleidingen over een wegwerp-VM voor coding agents en gebruikers met minimale rechten op een VPS beschrijven de configuratie. Claude Code veilig uitvoeren op een VPS beschrijft het dagelijks gebruik.
Haal de secrets uit de omgeving
Elke child process kan een omgevingsvariabele lezen. Dat betekent dat elke opdracht die de agent uitvoert deze kan lezen. De sandbox van Claude Code kan benoemde variabelen vóór elke opdracht in de sandbox verwijderen. Op Linux heeft de sandbox eerst twee packages nodig:
sudo apt-get install bubblewrap socatOp Ubuntu 24.04 en later voorkomt het standaardbeleid van AppArmor dat bubblewrap de benodigde user namespaces aanmaakt. Als sysctl kernel.apparmor_restrict_unprivileged_userns 1 retourneert, voegt u het korte AppArmor-profiel voor bwrap toe dat de documentatie over sandboxing van Claude Code verstrekt. Laad AppArmor daarna opnieuw.
Voer vervolgens in ~/.claude/settings.json het volgende uit:
{
"sandbox": {
"enabled": true,
"network": {
"allowedDomains": ["github.com", "*.npmjs.org"],
"strictAllowlist": true
},
"credentials": {
"envVars": [
{ "name": "GITHUB_TOKEN", "mode": "deny" },
{ "name": "NPM_TOKEN", "mode": "deny" }
]
}
}
}Een vermelding voor deny verwijdert die variabele voordat elke opdracht in de sandbox wordt uitgevoerd. allowedDomains vermeldt de hosts die opdrachten in de sandbox mogen bereiken. Zonder strictAllowlist bepaalt uw permissiemodus wat er gebeurt met een host die niet in die lijst staat: de handmatige modus toont een prompt en de automatische modus laat de classifier extra hosts openen voor één opdracht. strictAllowlist weigert elke host die niet op de lijst staat. Hiervoor is Claude Code v2.1.219 of later vereist. De instelling werkt alleen vanuit gebruikersinstellingen of beheerde instellingen en kan dus niet door een repository worden uitgeschakeld (gecontroleerd in October 2026). Voor het blok credentials is Claude Code v2.1.187 of later vereist; dit is gecontroleerd in August 2026. Voer /sandbox uit in een sessie om te zien welke lagen actief zijn en welke afhankelijkheden ontbreken. Bepalen welke secrets überhaupt op die machine aanwezig moeten zijn, is het grootste deel van het werk. Secrets buiten het bereik van een AI-agent houden helpt u daarbij.
Beperk uitgaand netwerkverkeer in het besturingssysteem
Een firewallregel houdt geen rekening met wat het model heeft besloten. Voer de agent uit als een speciale gebruiker agent en blokkeer vervolgens het verkeer dat deze gebruiker verzendt:
table inet agentcage {
chain output {
type filter hook output priority filter; policy accept;
meta skuid "agent" ct state established,related accept
meta skuid "agent" oif lo accept
meta skuid "agent" counter drop
}
}De gebruiker agent heeft hierdoor alleen toegang tot loopback. Het netwerkverkeer moet daarom via een proxy op dezelfde machine lopen. De proxy bevat de allowlist met hostnamen. Als https_proxy naar die proxy verwijst, verzendt de client een CONNECT-verzoek en voert de proxy de naamresolutie uit. De agent heeft dan geen eigen uitgaande DNS (domain name system) nodig. Controleer uw werk met sudo nft list ruleset en controleer of de teller op de blokkeerregel oploopt wanneer de agent een nieuwe bestemming probeert te bereiken.
Houd een tweede SSH-sessie open terwijl u firewallwijzigingen toepast. Controleer ook hoe uw container runtime met deze regels omgaat. Docker schrijft eigen chains en gepubliceerde Docker-poorten omzeilen ufw beschrijft de verrassende consequentie daarvan.
Hooks: de controle waar het model niet omheen kan praten
Permissieregels en hooks worden afgedwongen door Claude Code, niet door het model. De documentatie stelt dit duidelijk: instructies in uw prompt of in CLAUDE.md bepalen wat Claude probeert te doen. Ze veranderen niet wat Claude Code toestaat. Dat onderscheid vormt de hele waarde. Een regel in CLAUDE.md met de tekst "never run curl" is een suggestie waar een geïnjecteerde alinea tegenin kan gaan. Een hook is een proces dat een exitcode retourneert.
Registreer een PreToolUse-hook in .claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [
{
"type": "command",
"command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/no-egress.sh"
}
]
}
]
}
}De hook ontvangt de toolaanroep als JSON op standard input. Exitcode 2 blokkeert de aanroep en toont Claude de reden op standard error. Exitcode 0 laat de aanroep doorgaan via de normale permissiestroom.
#!/usr/bin/env bash
# PreToolUse: stdin holds the tool call, exit 2 blocks it.
cmd=$(jq -r '.tool_input.command // ""')
if printf '%s' "$cmd" | grep -qE '(^|[;&|]|\s)(curl|wget|nc|ncat)(\s|$)'; then
echo "Blocked: this repository does not allow outbound network commands." >&2
exit 2
fi
exit 0Nu het belangrijke voorbehoud. Dit is een denylist op basis van een shell-string. Denylists op shell-strings zijn niet sluitend. python3 -c opent een socket zonder het woord curl te gebruiken. Een doel met make deploy verbergt dezelfde aanroep nog een niveau dieper. Schrijf hooks voor fouten die u kunt benoemen. Plaats de grens waarop u daadwerkelijk vertrouwt in de kernel of op het netwerk.
Permissieregels met deny hebben een belangrijke beperking. Deny-regels voor Read en Edit gelden voor de eigen file tools van Claude en voor bestandsopdrachten die Claude in Bash herkent, zoals cat, head, tail en sed. Ze gelden niet voor een Python- of Node-script dat het bestand zelf opent. Regels worden eerst als deny, daarna als ask en vervolgens als allow geëvalueerd. Een deny-regel kan daarom geen uitzondering met een allowlist bevatten.
{
"permissions": {
"deny": [
"Read(.env)",
"Read(./secrets/**)",
"Bash(git push *)"
]
}
}Controleer wat naar buiten gaat en lees de diff
Een agent-run produceert een diff en een reeks netwerkverbindingen. Beide moeten worden gecontroleerd voordat u iets samenvoegt of implementeert. Een zelfgehoste beveiligingscontrole van de diff detecteert een ander type wijziging dan een snelle menselijke controle. Weten wat een coding agent van de machine verstuurt laat zien hoe normaal netwerkverkeer eruitziet, zodat een afwijkend verzoek opvalt.
Wat is nog onopgelost
Er bestaat vandaag de dag geen betrouwbare scheiding tussen inhoud en instructie. Elke verdediging die wordt uitgebracht is ofwel een filter met een foutmarge, ofwel een beperking van de gevolgen. Niets in de stack markeert een tekstblok als data die nooit mag worden opgevolgd.
Filters helpen wel degelijk, maar ze falen ook. Een classifier die de meeste injectiepogingen onderschept, moet elke keer gelijk hebben, terwijl een aanvaller slechts één keer gelijk hoeft te hebben. Die asymmetrie is de reden waarom een gepubliceerd succespercentage van een verdediging het startpunt is voor de volgende poging, in plaats van een garantie.
Het meest veelbelovende werk bevindt zich op het niveau van het ontwerp in plaats van op het niveau van het model. CaMeL, uit Defeating Prompt Injections by Design (Debenedetti en collega's, 2025), extraheert eerst de control flow en data flow uit het vertrouwde verzoek, zodat niet-vertrouwde data niet kan veranderen wat het programma doet, en dwingt vervolgens capability-checks af wanneer tools worden aangeroepen. De eigen cijfers van het paper op de AgentDojo-benchmark laten zien wat dat kost.
De gegevens achter deze grafiek
[
{
"label": "Undefended agent",
"tasks_solved_pct": 84
},
{
"label": "CaMeL",
"tasks_solved_pct": 77
}
]De onverdedigde agent loste 84 procent van de taken op. CaMeL loste 77 procent op met een bijbehorende beveiligingsgarantie. Dit zijn de gepubliceerde cijfers van het paper op één benchmark en geen meting van uw eigen werklast. Het verschil daartussen is grofweg wat een echte garantie vandaag de dag kost.
Totdat een dergelijk ontwerp wordt uitgebracht in de tools die u dagelijks gebruikt, moet u ervan uitgaan dat de agent op enig moment gecompromitteerd raakt en moet u zorgen dat die gebeurtenis onbeduidend is. Dat is het hele argument voor een wegwerpmachine, beperkte credentials, gecontroleerd uitgaand verkeer en de gewoonte om de diff te lezen.
FAQ
Kan ik prompt injection voorkomen door de agent te instrueren instructies in bestanden te negeren?
Nee. Die zin is tekst in hetzelfde contextvenster als de aanval en concurreert op gelijke voet met de tekst van de aanvaller. De documentatie van Claude Code trekt hier een duidelijke grens: instructies in uw prompt of CLAUDE.md bepalen wat de agent probeert te doen, maar ze veranderen niets aan wat de tool toestaat. Beschouw een instructiebestand als een intentieverklaring en plaats alles waar u op vertrouwt in toegangsregels, een PreToolUse hook of een firewallregel.
Is prompt injection een reëel risico als de agent alleen mijn eigen repository aanraakt?
Ja, want uw repository staat vol met tekst die u niet zelf heeft geschreven. README-bestanden van dependencies, URL's in lockfiles, test-fixtures, vendored code en de output van npm install komen allemaal binnen tijdens een normale taak. Alles wat uit een issue tracker of een documentatiesite wordt gehaald, komt op dezelfde manier binnen. Het risico groeit naarmate de agent meer leest, en een nuttige agent leest veel.
Lost het draaien van de agent in een container dit op?
Het beperkt de schade, maar alleen als u ook de inloggegevens verwijdert. Een container met uw doorgegeven SSH-agent, cloud-inloggegevens in de omgeving en onbeperkte netwerktoegang geeft een aanvaller bijna alles wat de host ook zou bieden. Wat de container u werkelijk oplevert, is een bestandssysteem dat u kunt verwijderen en een schone plek om uitgaand netwerkverkeer (egress) te beperken. Combineer dit met een token dat beperkt is tot één repository.
Welke enkele wijziging verkleint het risico het meest?
Verwijder langdurig geldige inloggegevens uit de omgeving die de commando's van de agent overneemt en geef die machine vervolgens een default-deny beleid voor uitgaand netwerkverkeer. Samen doorbreken ze de derde voorwaarde in de dodelijke combinatie: tekst kan de agent nog steeds kapen, maar de data die de agent bereikt, kan nergens nuttigs heen. Goedkeuringsprompts en diff-reviews helpen ook, maar zij zijn afhankelijk van een mens die alert blijft tijdens een lange sessie; daarom staan ze lager op de prioriteitenlijst dan die twee wijzigingen.