We hebben vijftien jaar nodig gehad om te leren dat je een database niet op het open internet zet. MongoDB met losgeldbriefjes erin. Elasticsearch-clusters die wagenwijd openstonden. Redis-instances waar iedereen zomaar verbinding mee kon maken. Stuk voor stuk een tool gebouwd voor een vertrouwd lokaal netwerk, door iemand met haast op een publiek IP gezet.
De les is geleerd. En toen bouwden we een nieuw soort endpoint, gaven het een tool die execute heet, en zetten er 12.500 van terug op het internet.
Censys heeft het in kaart gebracht. Eind april telden ze 12.520 MCP-services die direct aan het internet hingen, verspreid over 8.758 IP-adressen. Een week later waren het er al meer dan 21.000. Ongeveer 40% accepteert verzoeken zonder authenticatie. Geen key, geen token, geen login. Gewoon een open poort die Model Context Protocol spreekt.
Dat is geen lek. Dat is een voordeur zonder slot, van een huis vol elektrisch gereedschap.
Het protocol is niet de boosdoener
Een paar dagen geleden schreef ik over de MCP-supply chain, de config-to-command RCE die in de officiële SDK's zit ingebakken. Dat ging over de code die je installeert. Dit is de andere helft: de server die je zelf opzet en vergeet op slot te doen.
En voor de duidelijkheid: het ontwerp is niet het probleem. MCP is local-first gebouwd. De aanname was een vertrouwde grens: de server draait op je eigen machine, of binnen je netwerk, en praat met een agent die jij beheert. Binnen die grens is authenticatie overslaan een redelijke default. Het is dezelfde reden waarom Postgres standaard op localhost luistert met trust-auth. Handig, en prima, precies tot iemand hem aan 0.0.0.0 bindt.
Het protocol ging uit van een muur. Mensen hebben het uitgerold zonder die muur.
Zet je een local-first MCP-server op het open internet, dan vereist de spec geen authenticatie, en dus heb je in feite een RPC-endpoint zonder authenticatie gepubliceerd. Wie hem vindt, krijgt dezelfde toegang als jouw agent. En jouw agent is het proces op je machine met de meeste rechten, dat ook nog eens het meeste vertrouwt.
Erger dan een database
Dit is mijn stelling, en daar wijk ik niet van af: een open database is erg, maar een open MCP-server is erger.
Een database die openligt lekt zelfstandige naamwoorden. Rijen, documenten, keys. Verschrikkelijk, maar begrensd. Je verliest de data die erin zat.
Een MCP-server die openligt lekt werkwoorden. Hij zit daar niet alleen data vast te houden. Hij doet dingen. Kijk naar wat die servers daadwerkelijk aanbieden. In het hele ecosysteem zijn de meest voorkomende capabilities netwerktoegang, toegang tot het bestandssysteem, en het beheren van secrets. Precies de drie die je bovenaan je lijstje "dit nooit blootstellen" zou zetten, en precies de drie die een MCP-server het vaakst kan.
Een datalek is iemand die in je archiefkast leest. Een open MCP-server is iemand die je kantoor binnenloopt en jouw handen gebruikt. Hij kan bestanden lezen, interne services bereiken en credentials ophalen, want dat is de taak die jij hem gaf. De aanvaller heeft geen exploit nodig. Hij heeft de URL nodig.
Dit is het gat dat niemand echt doorhad in de haast om overal agents aan te koppelen. We behandelden MCP-servers als API-endpoints, web-achtige dingen die je achter een load balancer hangt en verder vergeet. Het zijn geen endpoints. Het zijn handen op afstand.
De spec liet het toe, dus deed je het
Het zou nog wat zijn als het onveilige pad lastig was. Dat is het niet. Het is juist het makkelijke pad.
De spec verplicht geen authenticatie. De local-first defaults werken je niet tegen als je ze blootstelt. Dus de weg van de minste weerstand, wat er gebeurt zodra een engineer gewoon wil dat de remote agent bij de server kan, is een open poort. Het veilige pad kost extra werk. Het onveilige pad is gratis. We weten precies wat developers massaal doen als je beveiliging zo beprijst.
Zelfs de servers die wél de moeite namen, deden meestal het minimum. Van de servers mét authenticatie gebruikt 53% een enkele statische API-key. Eén langlevende credential, geen vervaldatum, geen scope per operatie. Lek hem één keer, in een log, een screenshot, een git-commit, en hij is een loper tot iemand het doorheeft. Dat is geen authenticatie. Dat is een wachtwoord op een geeltje aan je scherm.
En de bijbehorende stoet bugs is precies wat je verwacht bij mensen die snel bouwen in een jong ecosysteem. Eén scanner, VIPER-MCP, ging door zo'n 40.000 server-repositories heen en vond 106 zero-days, goed voor 67 CVE's. Negen daarvan kwamen voort uit kapotte OAuth-flows, wat een eigen tragikomedie is: de servers die authenticatie wél goed probeerden te doen, bouwden er kwetsbaarheden mee in.
We hebben deze film al gezien
Niets hiervan is nieuw. Dat is het deprimerende.
MongoDB luisterde jarenlang standaard op alle interfaces zonder authenticatie, en we kregen er een heel ransomware-seizoen voor terug. Elasticsearch en Kibana, wagenwijd open, terwijl ze de incidentrapporten van de hele wereld indexeerden. Redis, het eeuwige voorbeeld, een service zo goedgelovig dat een open instance neerkomt op remote code execution als je het trucje kent. Blootgestelde Docker-sockets. Publieke Kubernetes-dashboards. Memcached-amplificatie die een halve middag het halve internet platlegde.
Het patroon is elke keer identiek. Een tool die is geoptimaliseerd voor wrijvingsloze lokale ontwikkeling wordt op een publiek IP gezet omdat iemand toegang op afstand nodig had en de deadline gisteren was. De defaults zijn nooit voor die omgeving geschreven, en de defaults winnen.
MCP betreedt hier geen nieuw terrein. Het speelt dezelfde wedstrijd, alleen sneller. MongoDB had jaren nodig om een waarschuwend voorbeeld te worden. MCP deed er ongeveer achttien maanden over, omdat de adoptiecurve steiler is en wat er blootgesteld wordt gevaarlijker is dan een documentstore ooit was.
Als de NSA je een brief schrijft
Aan wie erover begint te schrijven, zie je meestal of een technologie haar eigen veiligheidscultuur voorbij is gehold.
Halverwege 2026 bracht de NSA een Cybersecurity Information Sheet uit over de beveiliging van Model Context Protocol. Geen blogpost. Geen whitepaper van een leverancier. Een inlichtingendienst die formele richtlijnen publiceert over een protocol dat drie jaar geleden nog niet bestond.
Lees wat er staat, en lees wat het impliceert. Het noemt authenticatiecontroles en verdediging tegen prompt-injectie verplichte maatregelen, geen optionele hardening. Het wil tool-API's met minimale rechten, end-to-end audit logging van elke aanroep met parameters en identiteiten, en tools gescheiden per dataclassificatiezone, zodat het publieke spul niet bij het gevoelige spul kan.
Dat is een verstandige lijst. Het is ook, regel voor regel, een beschrijving van alles wat het ecosysteem zonder heeft uitgerold. Je zegt mensen niet dat ze authenticatie moeten toevoegen tenzij een hoop van ze het oversloeg. De advisory is een bekentenis tussen de regels door: de uitrol holde de governance voorbij, en nu leggen de volwassenen de ondergrens vast.
Wat je daadwerkelijk dichttimmert
Je hebt de volledige checklist van de NSA niet nodig om niet langer bij die 12.500 te horen. Je moet stoppen met een MCP-server als een webpagina te behandelen.
- Standaard op localhost. Bind aan een loopback-adres of een unix-socket. De overgrote meerderheid van de MCP-servers heeft helemaal niets te zoeken op een publieke interface. Draaien je agent en je server op dezelfde machine, dan hoeven ze het netwerk nooit aan te raken.
- Moet het remote, zet er authenticatie voor. Geen uitzonderingen. Een reverse proxy met echte authenticatie, mutual TLS, of een tunnel die identiteit vereist. Een MCP-server op een publiek IP zonder authenticatie is niet "blootgesteld", die is weggegeven.
- Behandel hem als een database, niet als een endpoint. Ga ervan uit dat publiek bereikbaar gelijkstaat aan gecompromitteerd, en ontwerp vanuit dat punt. Netwerkbeleid, IP-allowlists, alles erop en eraan. Je zet Postgres ook niet op
0.0.0.0met trust-auth. Dezelfde regel. - Schaf de statische keys af. Als 53% van de servers met authenticatie op één langlevende credential steunt, zit dan niet in die 53%. Kortlevende tokens met scope. Roteer ze. Dezelfde logica van een grens op systeemniveau boven vriendelijk vragen geldt: een credential die verloopt is een echte grens, een credential die je van plan bent te roteren is een goed voornemen.
- Minimale rechten op capabilities. Heeft deze server echt het bestandssysteem én het netwerk én secrets nodig? Waarschijnlijk niet. Elke capability die je toekent is een werkwoord dat je in handen geeft van wie er ook bij kan. Dezelfde reflex om het proces in te kapselen die ik op mijn eigen server toepaste: ga uit van vijandig, geef het minimum.
- Weet wat je hebt. Je kunt geen inventaris beveiligen die je niet kunt zien. Dat is mede waarom ik MCP Observatory heb gebouwd: om de releases, CVE-feeds en risicoscores van het ecosysteem bij te houden, inclusief de netwerk- en secrets-capabilities die een open poort tot een echt probleem maken. Voordat je een server vertrouwt, zorg dat je weet of het een bekende grootheid is of een vreemde met handen.
De ongemakkelijke waarheid is dat bijna niets hiervan nieuw beveiligingswerk is. Het is dezelfde hygiëne die we de afgelopen vijftien jaar met vallen en opstaan hebben uitgevogeld bij elke paniek rond blootgestelde services. Lokaal binden. Remote authenticeren. Minimale rechten. Credentials roteren. Je inventaris kennen.
Dat draaiboek hebben we al in bloed geschreven. MCP gaf het ons gewoon terug met een tool-lijst eraan vast, en een hoop mensen lezen het voor het eerst.
De deur was nooit op slot. Alleen staat de kamer nu, als iemand naar binnen loopt, vol met dingen die namens jou kunnen handelen.