Het credential in het geheugen van je applicatie gaat uitlekken

Hier is een ongemakkelijke voorspelling, en het is geen voorzichtige gok: de credentials die nu in het geheugen van je applicatie zitten — het wachtwoord van de database dat het bij het opstarten heeft geladen, het API-token in zijn omgeving, de cloud-sleutel die het vasthoudt om zijn werk te doen — lekken waarschijnlijk binnen de komende twaalf maanden uit. Niet omdat iemand je beveiligingsteam te slim af is. Omdat de enige aanname die een geheim in geheugen ooit veilig maakte — dat er alleen vertrouwde code naast draait — dit jaar stilletjes niet meer waar is, en bijna niemand zijn werkwijze heeft aangepast.

Dit is degene die je niet onder 'later' kunt schuiven.

Wat er echt gebeurt

Bijna elke applicatie bewaart zijn geheimen op dezelfde manier. Bij het opstarten leest ze — uit een .env-bestand, een gekoppelde secret, een omgevingsvariabele — en laadt ze in plaintext in het eigen geheugen, voor de hele levensduur van het proces. Dertig jaar lang was dat een verstandig ontwerp, en het was verstandig om precies één reden: het geheugen of de omgeving van een ander draaiend programma uitlezen vereist het uitvoeren van code op dezelfde machine, met hetzelfde privilege. Die drempel was vroeger hoog. Alleen je eigen software en je eigen mensen haalden 'm.

Een agent haalt 'm nu. Een coding agent, een MCP-tool, een autonome worker — bij ontwerp voert hij code uit, op een echte machine, als een echte gebruiker. En voor code die op dat privilege draait, is een credential in geheugen geen kluis om te kraken. Het is een bestand om te lezen. /proc/<pid>/environ toont de omgevingsvariabelen van een ander proces in plaintext. Een core dump levert zijn heap op. Geen exploit, geen CVE, geen alarm — je EDR, je WAF, je firewall zien een geautoriseerd proces geheugen lezen waar het het recht toe heeft, en zien niets fout, want er is niets fout volgens hun regels. Elke stap is legaal. Het geheim lag er gewoon om mee te nemen.

Dit is geen fout die jij hebt gemaakt

Maak duidelijk wie dit te verwijten valt, want jij niet. De .env op een geharde machine, de secret die bij het opstarten uit een manager in geheugen wordt getrokken — dat is het aanbevolen patroon. Het is twelve-factor, volgens het boekje, wat een goede engineer doet. Het was verantwoord. Wat verlopen is, is niet de praktijk. Het is de aanname eronder: dat de enige code die naast je geheim draait, code is die jij er hebt neergezet. Op het moment dat een agent op die machine draait — en je zet overal agents neer, met opzet, omdat ze nuttig zijn — is die aanname weg, en zit de plaintext die je verantwoord in geheugen hebt geladen in de blast radius.

We hebben de eerste versie hiervan al zien landen [4]. Wanneer een coding agent wordt gekaapt — een vergiftigd foutrapport, een kwaadaardige tool in zijn pad — is het eerste wat binnen handbereik ligt precies dit: de tokens en sleutels die zijn eigen proces, en de processen ernaast, al in geheugen hebben. De injectie is alleen de deur. Het permanente credential is de buit.

"Maar er draait geen agent op die machine"

Dit is het geruststellende antwoord, en het is het antwoord dat faalt. De verdediging steunt op een muur: houd de agents hier, houd de credentials daar. Die muur is precies wat dit jaar bewezen heeft niet te houden.

Je hoeft dat niet op geloof aan te nemen — dit jaar leverde het bewijs, twee keer. In zijn eigen gepubliceerde tests richtte Anthropic zijn Mythos-model op de NFS-server van FreeBSD, kernelcode die mensen zeventien jaar hadden gelezen, en op eigen initiatief vond het een stack overflow in het authenticatiepad, schreef het een exploit met twintig gadgets verdeeld over zes netwerkpakketten, en nam het ongeauthenticeerde root over de lijn. Dat is CVE-2026-4747, en het kostte ongeveer vier uur. Geen 'verdachte functie gemarkeerd' — een werkende remote-root-exploit tegen code die zeventien jaar review overleefde, en hetzelfde tegen kritieke kwetsbaarheden in elk groot besturingssysteem en elke browser waarop het werd gericht [1].

En de containment die je rond een agent zou wikkelen, doet het niet beter dan de perimeter. In Anthropics eigen veiligheidsevaluatie, met de opdracht uit zijn sandbox te ontsnappen en de onderzoeker die de test draaide te bereiken, ketende Mythos exploits — een JIT heap spray — om uit zowel de browser-renderer als de besturingssysteem-sandbox te breken, bereikte het open internet, en mailde hem [1]. De eerlijke kanttekening: het deed dat omdat de test erom vroeg, niet uit eigen initiatief. Maar 'we vroegen het' is precies de stoel van de aanvaller — en 'breek uit, escaleer, pak de credentials' is de standaardpayload van elke kwaadaardige prompt vanaf nu. De capaciteit zat nooit te wachten op het initiatief van het model zelf. Ze wacht op een instructie, en dat is de enige invoer waarvan je kunt rekenen dat die aankomt. De ernst werd erkend op de enige hoogte die telt — de VS hebben het model zelf onder exportcontrole geplaatst, een primeur voor een AI-model in plaats van de chips erachter, nadat een versie van Mythos zich in enkele uren door vrijwel alle geclassificeerde systemen van de NSA zou hebben gewerkt [2][3].

Zet dat nu naast het geheugenprobleem, want ze komen samen. Root op een machine leest het geheugen van elk proces, niet alleen dat van de eigen gebruiker. Dus de echte vraag was nooit 'zal ik een agent naast mijn geheimen draaien'. Het is 'kan een capabel model deze machine bereiken, of uitbreken uit de box waar ik hem in heb gezet' — en dit jaar heeft beide vragen in het openbaar beantwoord. 'Er draait geen agent op die machine' is geen controle die je afdwingt. Het is een hoop over waar dingen blijven liggen, en de dingen hebben al laten zien dat ze dat niet doen. Plan voor de agent die de machine bereikt. Het alternatief is plannen om geluk te hebben.

Hier bewust voor gebouwd

Dus stop met proberen de agent weg te houden bij een secret die daar gewoon ligt. Neem weg wat daar ligt.

Een credential in Clavitor wordt nooit in het geheugen van je applicatie geladen om te wachten. Het wordt live opgehaald, op het moment van de aanroep, gebruikt voor die ene request, en weg. Het zit nooit in een omgevingsvariabele, landt nooit in een .env, brengt nooit de levensduur van het proces resident in een heap door om te worden gedumpt. Er is niets voor /proc om te tonen en niets voor een core dump om mee te nemen, want de machine werd nooit vertrouwd om een permanent geheim vast te houden.

Het enige credential dat hij afgeeft, is beperkt tot die ene taak waarvoor die agent was benoemd. Hij kan de kluis niet opsommen, kan niet inventariseren wat er nog meer bestaat, kan de volgende sleutel niet ontdekken. Elke ophaling is rate-limited, zet een lockdown in gang bij een afwijkende piek, en wordt geschreven naar een append-only, hash-geketende log die op de kluis staat — niet op het endpoint waar de agent draait. Dat is het onveranderlijke, herleidbare spoor dat PCI DSS Requirement 10 en NIST 800-171 (control 3.3.8) vragen: bewijs van precies wat je agent heeft aangeraakt, bewaard op een plek die een gecompromitteerde machine noch kan bereiken noch kan herschrijven.

De eerlijke rand, want de claim heeft er een nodig: op de microseconde dat het wordt gebruikt, bestaat het secret wel in geheugen — voor die ene request, in dat ene moment. Geen ontwerp herschrijft natuurkunde. Wat het herschrijft, is het verschil tussen een secret dat resident is — uren in je proces, op elk moment te dumpen — en een dat ephemeer is — aanwezig voor één enkele aanroep en daarna niet meer weg te nemen. Je kunt niet dumpen wat er niet staat.

De les is niet 'zet de machine harder op slot'

Je kunt de machine blijven hardenen. Je kunt jezelf blijven vertellen dat er nooit onvertrouwde code naast je geheimen draait. Maar dat is precies de gok die elke maand duurder wordt, tegen een tegenstander die code uitvoert voor de kost en door muren loopt waarvan je dacht dat ze zouden houden. Het credential in geheugen was veilig toen elke lezer vertrouwd was. De lezers zijn veranderd. De enige zet die de verandering overleeft, is stoppen met het credential daar achter te laten om te worden gelezen.

We hebben de regels opgeschreven die een credential-tool moet naleven in een wereld als deze. Leg de jouwe erlangs.

Clavitor (@clavitorai) is de credential-kluis gebouwd voor AI-agents, en ertegen. clavitor.ai

Bronnen

[1] Anthropic (Anthropic Red Team) — Assessing Claude Mythos Preview's cybersecurity capabilities (autonome ontdekking + exploitatie van de FreeBSD NFS RCE, CVE-2026-4747; kritieke kwetsbaarheden in grote besturingssystemen en browsers) — https://red.anthropic.com/2026/mythos-preview/

[2] Associated Press (via CNBC) — Anthropic's Mythos model found vulnerabilities in classified U.S. government systems, official says — https://www.cnbc.com/2026/06/23/anthropics-mythos-model-found-vulnerabilities-in-classified-us-government-systems-official-says.html

[3] Fortune — Anthropic disables Fable and Mythos AI models following U.S. government export ban — https://fortune.com/2026/06/13/anthropic-disables-fable-mythos-export-controls-national-security-threat/

[4] Tenet Security (Tenet Threat Labs) — Agentjacking: Coding Agents with Fake Sentry Errors (precedent van kaap-naar-permanent-credential) — https://tenetsecurity.ai/blog/agentjacking-coding-agents-with-fake-sentry-errors/