Gisteren was het bij heel wat bedrijven waarschijnlijk een veelgestelde vraag: “Hebben we PHP in da house?”
Jazeker! En als je de hele middag met PHP bezig bent, dan mag je jezelf best even René van de PePHPel noemen. Met een extra h ertussen, uiteraard.
Maar grapjes over mijn achternaam zijn één ding. De beveiligingsupdate die gisteren voor PHP verscheen, was een stuk serieuzer.
Sterker nog, de buuf appte zelfs al of ik daar nog last van had!
Maar achter die update gaat een verhaal schuil dat veel verder reikt dan alleen een programmeertaal.
Wat als AI straks niet alleen helpt om software te bouwen, maar ook steeds beter wordt in het vinden van ernstige beveiligingslekken? Niet alleen in PHP, maar ook in Python, JavaScript-packages, servers, routers en allerlei andere apparaten die dagelijks onze digitale wereld draaiende houden?
Vandaag PHP, morgen Python en overmorgen… wat staat er dan op het programma?
Dat is niet alleen een interessante ontwikkeling voor programmeurs. Het raakt iedereen die software ontwikkelt, gebruikt of beheert.
En misschien is de belangrijkste vraag wel: als AI steeds sneller kwetsbaarheden kan vinden, kunnen we ze dan ook snel genoeg oplossen?
Een fout die er al jaren zat
Op 21 oktober 2026 verscheen een beveiligingsupdate voor PHP vanwege twee kritieke kwetsbaarheden. Onder bepaalde omstandigheden konden aanvallers daarmee op afstand code uitvoeren op een kwetsbare server, zonder eerst in te loggen.
De ernstscore was 9,2 op een schaal van 10.
Het bijzondere is dat een van de onderliggende problemen al in 2024 was opgemerkt. De daadwerkelijke impact en aanvalsmogelijkheden werden pas later duidelijk.
In 2026 onderzochten verschillende beveiligingsonderzoekers de kwetsbaarheid verder. Daarbij werd AI ingezet om de code te analyseren en mogelijke aanvalsroutes te onderzoeken. De PHP Foundation beschrijft hoe AI-ondersteund onderzoek, onder meer door Calif en OpenAI, hielp om de ernst van het probleem verder bloot te leggen.
Een belangrijke nuance: AI ontdekte niet in zijn eentje ineens een compleet onbekende fout. Er waren eerdere aanwijzingen, meerdere onderzoekers waren betrokken en uiteindelijk moesten menselijke ontwikkelaars de bevindingen beoordelen en de software repareren.
Maar het laat wel zien hoe AI kan helpen om ingewikkelde beveiligingsproblemen sneller en grondiger te onderzoeken.
Bronnen: PHP Foundation en OpenAI — Coordinated Disclosure of Critical Vulnerabilities.
Vandaag PHP, morgen Python?
PHP is natuurlijk niet de enige programmeertaal waarin beveiligingsfouten kunnen zitten.
Morgen kan er een ernstig lek worden ontdekt in Python. Of in een npm-package dat door duizenden JavaScript-projecten wordt gebruikt. Of in een webserver, database, router, VPN-apparaat of stukje firmware dat ergens al tien jaar probleemloos lijkt te draaien.
Vandaag in PHP, morgen in Python, overmorgen in npm. Hebben we nog meer talen in da house?
Het klinkt grappig, maar de onderliggende vraag is serieus.
Vrijwel iedere moderne applicatie bestaat uit een combinatie van eigen code, externe bibliotheken, frameworks en andere afhankelijkheden. Daarbovenop draaien besturingssystemen, containers, databases en netwerkcomponenten.
Een kwetsbaarheid hoeft dus helemaal niet in jouw eigen code te zitten. Ze kan zich bevinden in een bibliotheek waarvan je niet eens meer wist dat je die gebruikte.
En als AI steeds beter wordt in het analyseren van grote hoeveelheden code, kan het steeds aantrekkelijker worden om zulke onderzoeken op veel grotere schaal uit te voeren.
Dat betekent niet dat AI morgen alle fouten vindt. Ook betekent het niet dat iedere gevonden fout direct een bruikbare aanval oplevert.
Maar de drempel om beveiligingsonderzoek uit te voeren kan wel lager worden. En dat geldt helaas voor zowel de verdedigers als de aanvallers.
Hoe ver gaat dit?
Stel je eens voor dat AI niet alleen programmeercode onderzoekt, maar ook complete softwarelandschappen.
Routers, switches, firewalls, servers, IoT-apparaten, industriële controllers, slimme camera's en de software die onze gebouwen en installaties aanstuurt.
Al die apparaten draaien software. Soms moderne software die regelmatig updates krijgt, soms firmware die jarenlang nauwelijks wordt aangeraakt.
Wat gebeurt er als AI steeds beter wordt in het vinden van fouten in die systemen?
Hoeveel kwetsbaarheden blijken er nog te bestaan die nooit zijn ontdekt? Hoeveel daarvan zijn inmiddels wel bekend, maar nog niet opgelost? En hoeveel systemen blijven kwetsbaar omdat niemand weet dat ze überhaupt aanwezig zijn?
Dat laatste is misschien wel het grootste probleem.
Want je kunt pas iets repareren als je weet dat het bestaat.
De aanval wordt slimmer. Gelukkig de verdediging ook.
Tot zover het ietwat ongemakkelijke deel van het verhaal.
Gelukkig heeft deze ontwikkeling ook een positieve kant. Dezelfde AI-technologie die kan helpen om kwetsbaarheden te vinden, kan ook worden ingezet om systemen veiliger te maken.
Stel dat je AI laat helpen bij het controleren van je softwareversies.
Welke PHP-versies draaien er op de servers? Welke Python-versies worden gebruikt? Welke applicaties zijn afhankelijk van kwetsbare npm-packages? Welke Docker-images bevatten verouderde componenten?
En vervolgens: welke beveiligingsadviezen zijn van toepassing, welke systemen lopen daadwerkelijk risico en welke updates hebben de hoogste prioriteit?
Dat is een heel andere manier van werken dan wachten tot er een melding binnenkomt, iemand een ticket aanmaakt en vervolgens een zoektocht begint naar de server waarop die applicatie draait.
AI kan helpen om beveiligingsinformatie te vertalen naar concrete acties. Niet alleen signaleren dat er een probleem is, maar ook inzichtelijk maken waar het probleem zit, wat de mogelijke impact is en welke stappen nodig zijn om het op te lossen.
Natuurlijk moet je dat wel goed inrichten. Een AI-agent die zonder controle lukraak updates installeert, is niet per definitie veiliger. Tests, menselijke goedkeuring, logging en een mogelijkheid om terug te draaien blijven belangrijk.
Maar de potentie is enorm.
Weten wat je hebt, wordt steeds belangrijker
Hier zit volgens mij een van de grootste uitdagingen voor organisaties.
Je kunt de beste beveiligingstools ter wereld gebruiken, maar als je niet weet welke software er binnen je organisatie draait, blijft een belangrijk deel van je beveiliging een gok.
Een oude server die nog ergens een taak uitvoert. Een applicatie die jaren geleden voor een project is gebouwd. Een Python-script dat afhankelijk is van een verouderde bibliotheek. Een netwerkapparaat waarvan niemand precies weet welke firmware erop staat.
Het zijn niet altijd de grote, spectaculaire systemen die voor verrassingen zorgen. Soms zijn het juist de onderdelen die iedereen vergeten is.
Een actueel overzicht van software, hardware, versies, afhankelijkheden, eigenaren en locaties is daarom geen administratieve luxe. Het vormt de basis voor goed beveiligingsbeheer.
En als je die informatie eenmaal hebt, kun je er veel meer mee doen dan alleen een inventarislijst bijhouden.
Je kunt risico's prioriteren, kwetsbaarheden koppelen aan de systemen waarop ze van toepassing zijn en veel gerichter bepalen waar actie nodig is.
AI kan dat proces versnellen. Maar zonder betrouwbare inventarisatie blijft ook de slimste AI deels in het duister tasten.
De beveiligingsmarkt gaat hier nog veel van merken
We hebben het bij Bull's AI al eerder gehad over de groeiende markt voor cybersecurity.
Ik verwacht dat AI die ontwikkeling verder zal versnellen. Niet alleen omdat organisaties betere bescherming nodig hebben, maar ook omdat de hoeveelheid beveiligingsinformatie en het tempo waarin kwetsbaarheden worden ontdekt kunnen toenemen.
Denk aan geautomatiseerde kwetsbaarheidsscans, dependency-analyse, software-inventarisatie, patchmanagement en AI-systemen die beveiligingsmeldingen omzetten in concrete vervolgstappen.
Tegelijkertijd ontstaat er een nieuw probleem: als AI veel meer kwetsbaarheden aan het licht brengt, kunnen IT-teams worden overspoeld met meldingen.
Niet iedere kwetsbaarheid heeft dezelfde impact. Een ernstig lek in een publiek toegankelijke server vraagt iets anders dan een probleem in een geïsoleerd testsysteem.
De kunst wordt dus niet alleen om meer fouten te vinden, maar om sneller te bepalen welke fouten er werkelijk toe doen.
En ze vervolgens ook op tijd op te lossen.
En waar houdt het op?
Misschien is dat wel de belangrijkste vraag.
Als AI steeds beter wordt in het vinden van fouten, hoe ver gaat dat dan? Kunnen we straks complete softwarelandschappen doorlopend laten onderzoeken? Hoeveel kwetsbaarheden komen boven water die jarenlang onopgemerkt zijn gebleven?
En als verdedigers die mogelijkheden krijgen, krijgen aanvallers ze uiteindelijk ook.
AI is geen exclusief verdedigingsmiddel. Dezelfde technologie kan worden gebruikt om kwetsbaarheden op te sporen én om aanvallen te ontwikkelen.
Daarom wordt de snelheid waarmee we reageren steeds belangrijker.
Wie ontdekt een kwetsbaarheid als eerste? Hoe snel wordt er een oplossing gemaakt? Hoe snel krijgen beheerders die oplossing geïnstalleerd? En hoeveel systemen blijven ondertussen kwetsbaar?
De PHP-case laat zien dat zelfs volwassen software met een actief ontwikkelteam diepgewortelde problemen kan bevatten. AI kan helpen om die problemen bloot te leggen, maar lost ze niet vanzelf op.
Daarvoor blijven mensen, processen en goed beheer onmisbaar.
Misschien moet ik me toch maar omscholen…
Voorlopig blijf ik lekker programmeren. Maar ik vind het fascinerend om te zien hoe AI zich ontwikkelt van een hulpmiddel dat code schrijft naar een hulpmiddel dat ook de veiligheid van bestaande code kan onderzoeken.
Misschien moeten we AI niet alleen vragen om nieuwe software te bouwen, maar ook om kritisch te kijken naar alles wat we al hebben gebouwd.
Welke versies draaien er? Welke afhankelijkheden zijn kwetsbaar? Welke systemen verdienen als eerste aandacht? En hoe zorgen we ervoor dat een gevonden probleem niet ergens in een mailbox blijft liggen?
Want uiteindelijk heb je weinig aan een AI die een kritieke kwetsbaarheid ontdekt als niemand weet op welke server de betreffende software draait.
De toekomst van cybersecurity draait niet alleen om het vinden van fouten. Het draait om de snelheid waarmee we ze kunnen vinden, begrijpen en oplossen.
En als AI dat tempo drastisch verhoogt, zullen we onze manier van softwarebeheer daarop moeten aanpassen.
Misschien is dat wel de belangrijkste les van één ogenschijnlijk gewone PHP-update.
En die kassa van de foto? Die heeft geen update meer nodig, alleen af en toe een poetsbeurt. Was het met software maar zo eenvoudig. 😉
