Wanneer organisaties aan cybersecurity denken, gaat de aandacht vaak direct naar kwetsbare software. Verouderde plugins, ontbrekende patches of bekende CVE’s krijgen veel aandacht, en terecht: kwetsbaarheden kunnen misbruikt worden.
Maar in de praktijk zien wij iets anders. Veel van de meest impactvolle incidenten ontstaan niet door onbekende zero-days of ingewikkelde exploits, maar door eenvoudige configuratiefouten. Fouten die vaak al jarenlang aanwezig zijn, volledig onopgemerkt, en zonder technische kennis misbruikt kunnen worden.
In dit artikel leggen we uit waarom configuratiefouten vaak gevaarlijker zijn dan kwetsbare software en waarom ze in veel organisaties structureel onderschat worden.
Wat verstaan we onder configuratiefouten?
Configuratiefouten zijn geen programmeerfouten in de software zelf, maar fouten in hoe systemen zijn ingericht en gekoppeld. Denk bijvoorbeeld aan:
- Te ruime toegangsrechten (IAM-rollen, admin-accounts)
- Publiek toegankelijke opslag (S3-buckets, databases, fileservers)
- Ontbrekende of foutieve netwerksegmentatie
- Services die onnodig publiek bereikbaar zijn
- Default instellingen die nooit zijn aangepast
- Logging of monitoring die niet (goed) is ingeschakeld
De software kan technisch “up-to-date” en gepatcht zijn, maar alsnog onveilig functioneren door verkeerde instellingen.
Kwetsbare software: zichtbaar en tijdelijk
Kwetsbare software heeft één belangrijk voordeel: ze is meestal zichtbaar.
- Er bestaan CVE-nummers
- Scanners en monitoringtools signaleren problemen
- Vendors publiceren patches en updates
- Beheerders weten: “dit moet worden bijgewerkt”
Daarnaast zijn kwetsbaarheden vaak tijdelijk. Zodra er gepatcht wordt, verdwijnt het risico grotendeels.
Dat maakt kwetsbare software beheersbaar, mits patchmanagement op orde is.
Configuratiefouten: stil, structureel en vaak jarenlang aanwezig
Configuratiefouten werken anders.
- Ze leveren vaak geen foutmeldingen op
- Systemen blijven “gewoon werken”
- Er is geen patch die het probleem oplost
- Ze vallen vaak buiten standaard scans
Juist daarom blijven configuratiefouten vaak maanden of zelfs jaren bestaan.
Een publiek toegankelijke database zonder authenticatie werkt prima, totdat iemand besluit te kijken wat erin staat.
Geen exploit nodig: alleen toegang
Een belangrijk verschil:
bij kwetsbare software moet een aanvaller vaak nog iets doen om misbruik mogelijk te maken.
Bij configuratiefouten is misbruik vaak triviaal:
- Een URL openen
- Een poort benaderen
- Een API-call aanpassen
- Een permissie misbruiken die al bestaat
Er is geen ingewikkelde exploit nodig. Geen malware. Geen geavanceerde aanvalstechniek.
Dat verlaagt de drempel enorm, ook voor minder ervaren aanvallers.
Configuratiefouten leiden direct tot volledige impact
Veel configuratiefouten raken direct de kern van je omgeving:
- Authenticatie
- Autorisatie
- Netwerktoegang
- Datatoegang
Daardoor is de impact vaak groter dan bij één losse softwarekwetsbaarheid.
Voorbeelden uit de praktijk:
- Een verkeerd ingestelde IAM-rol leidt tot volledige cloudtoegang
- Een ontbrekende autorisatiecheck in een API maakt alle klantdata uitleesbaar
- Een slecht gesegmenteerd netwerk maakt laterale beweging mogelijk
- Een vergeten admin-interface biedt volledige controle over een applicatie
Dit zijn geen theoretische risico’s, maar scenario’s die we in pentesten regelmatig aantreffen.
Waarom configuratiefouten zo vaak voorkomen
Configuratiefouten ontstaan zelden door onkunde. Meestal zijn ze het gevolg van:
- Tijdgebrek (“dit fixen we later”)
- Complexiteit (cloud, microservices, CI/CD)
- Groei (meer systemen dan overzicht)
- Meerdere teams of leveranciers
- Veranderingen zonder herbeoordeling
Vooral in cloudomgevingen en moderne applicaties is het aantal instellingen enorm. Eén verkeerde keuze kan grote gevolgen hebben, zonder dat iemand het doorheeft.
Waarom scans ze vaak missen
Veel organisaties vertrouwen op vulnerability scanners. Die zijn nuttig, maar hebben beperkingen:
- Ze focussen op bekende kwetsbaarheden
- Ze kijken minder naar samenhang
- Ze begrijpen de context van je omgeving niet
- Ze signaleren zelden logische fouten in autorisatie of segmentatie
Configuratiefouten vragen om interpretatie en context, niet alleen detectie.
Wat een pentest anders doet
Een pentest kijkt niet alleen naar losse kwetsbaarheden, maar naar hoe systemen samenwerken.
- Welke toegang heeft een gebruiker of service?
- Wat gebeurt er als die toegang wordt misbruikt?
- Hoe kan een aanvaller zich verplaatsen?
- Welke combinaties van instellingen maken misbruik mogelijk?
Daarom worden configuratiefouten vaak pas zichtbaar tijdens een pentest, en niet tijdens een vulnerability scan.
Wat organisaties hiervan kunnen leren
De belangrijkste les is simpel:
Niet alles wat veilig lijkt, ís veilig.
Een up-to-date systeem kan nog steeds ernstig kwetsbaar zijn door verkeerde instellingen. Andersom kan een kleine configuratiewijziging soms meer risico reduceren dan weken patchen.
Goede beveiliging draait niet alleen om software, maar om inrichting, overzicht en periodieke toetsing.
Conclusie
Kwetsbare software is een reëel risico, maar meestal tijdelijk en zichtbaar. Configuratiefouten zijn vaak stil, structureel en direct impactvol. Juist omdat ze minder aandacht krijgen, vormen ze in de praktijk vaak een groter gevaar.
Wil je weten of jouw omgeving veilig is ingericht en niet alleen of alles is gepatcht, dan is een pentest onmisbaar.
Voor organisaties die eerst globaal inzicht willen krijgen in zichtbare risico’s, kan een gratis website security check een eerste stap zijn.