Naar hoofdinhoud

Dit was mijn grootste misverstand toen ik begon: ik dacht dat vulnerability management hetzelfde was als "een scanner draaien en de rapporten oplossen". Niets is minder waar. Een scanner is het makkelijke deel. Het echte werk zit in prioriteren, bijhouden en opvolgen — precies het deel waar de meeste organisaties (en developers) op vastlopen.

In dit deel van de CDSA-reeks behandel ik vulnerability management samen met security automation, omdat die twee onlosmakelijk met elkaar verbonden zijn: je kunt niet handmatig bijhouden wat je niet automatiseert.

Wat is vulnerability management?

Vulnerability management is geen momentopname maar een cyclus:

  1. Ontdekken — inventariseer wat er draait (servers, applicaties, dependencies, netwerkapparaten). Wat je niet weet, kun je niet beveiligen.
  2. Scannen — automatiseer het vinden van known weaknesses: verouderde software, verkeerde configuraties, ontbrekende patches.
  3. Beoordelen — niet alles is even ernstig. Een CVSS-score van 9.8 op een intern test-systeem zonder gevoelige data weegt anders dan een 7.0 op je productie-database.
  4. Prioriteren en verhelpen — patchen, mitigeren of expliciet accepteren (met onderbouwing!).
  5. Opnieuw scannen — bevestig dat het opgelost is, en rapporteer.

Die cyclus gaat door, elke week opnieuw. Het is onderhoud, net als je dependencies up-to-date houden.

Mijn eigen praktijk: Dependabot als mini vulnerability-programma

Ik heb hier al eerder over geschreven: Waarom ik Dependabot gebruik en Dependabot activeren. Wat ik toen nog niet schreef: dat is eigenlijk een minimaal vulnerability-management-programma.

  • Ontdekken + scannen: Dependabot controleert wekelijks mijn Composer-dependencies en GitHub Actions tegen de GitHub Advisory Database.
  • Beoordelen: de advisories komen met CVSS-scores en severity-labels (low/moderate/high/critical).
  • Prioriteren: ik fix kritiek direct, de rest plan ik in.
  • Verifiëren: composer audit als dubbelcheck, en de Dependabot-PR zelf is het bewijs dat het opgelost is.

Niet uit de lesbank, maar uit de praktijk. Vulnerability management kwam tijdens de opleiding zelf weinig aan bod — de meeste kennis heb ik opgedaan bij de bedrijven waar ik de afgelopen jaren heb gewerkt. Daar hielden we de CVE's goed in de gaten: met tools spoorden we ze op en losten we ze op met updates en patches. Er kwamen wekelijks nieuwe CVE's bij, dus het was continu werk — precies de cyclus die je hierboven leest.

Waarom prioriteren het echte werk is

In de praktijk zie ik drie valkuilen:

1. De ruis-valkuil. Een Nessus- of OpenVAS-scan levert honderden meldingen op. Zonder triage-strategie sta je in de ruis. Handige vuistregels:

  • Exploitability: is er een publiek bekende exploit? Dan telt "niet in mijn netwerk zichtbaar" niet als excuus.
  • Blootstelling: is het systeem internet-facing, of intern?
  • Impact: wat zit erachter? Een webserver met klantdata weegt zwaarder dan een printserver.

2. De schijnzekerheid-valkuil. "We hebben geen kritieke findings" klinkt goed, maar betekent vaak alleen: de scanner vond niets wat in zijn database staat. Zero-days en configuratiefouten zie je met een standaardscan niet.

3. De verwaarlozing-valkuil. Een vulnerability-programma zonder eigenaar en ritme sterft binnen een jaar. De cyclus moet onderdeel worden van je normale werk — net als tests draaien.

Security automation: de hefboom

Hier komt het onderdeel automation om de hoek kijken. Zonder automation is vulnerability management een bijbaan van 20 uur per week. Met automation is het een dashboard-check.

Wat werkt, van eenvoudig naar ver:

  • Automated dependency updates (Dependabot, Renovate) — het laaghangende fruit.
  • Geautomatiseerde scans in je pipeline — bijvoorbeeld Trivy of Grype voor containerimages, en secret scanning (gitleaks) bij elke commit. Een build die faalt op een kritieke CVE voorkomt discussie achteraf.
  • OS-scanning — Wazuh of OpenVAS op je servers, met geautomatiseerde rapportage.
  • Ticket-automatisering — findings die automatisch een issue aanmaken met eigenaar en SLA. Wat geen eigenaar heeft, wordt niet opgelost.

Op mijn eigen netwerk draait inmiddels mijn custom network scanner als vroege vorm hiervan: onbekende apparaten worden gemeld. De volgende stap is precies wat de opleiding beoogt: van "melden" naar "beoordelen en opvolgen".

Tools uit de labs. In de labs werkten we met Suricata, Wireshark en Zeek. Suricata en Zeek zijn de automatiseringskant: ze analyseren netwerkverkeer continu en signaleren verdachte patronen op basis van regels en scripts. Wireshark gebruikten we vooral voor de handmatige, diepgaande pakketanalyse. Samen vormen ze de basis van netwerkdetectie — het snijvlak tussen vulnerability management, monitoring en incidentanalyse.

Mijn advies

  1. Begin met inventarisatie, niet met scannen. Zonder asset-inventory is elke scan onvolledig. Wat draait er? Wie is de eigenaar?
  2. Eén keer goed triageren is beter dan tien keer scannen. Besteed tijd aan het classificeren van findings, niet aan het produceren van rapporten.
  3. Automatiseer het repetitieve deel. Scannen, rapporteren, tickets aanmaken: automatiseren. Beoordelen en beslissen: mensen.
  4. Koppel je scan-resultaten aan je dependencies. Dependency-scanning (Dependabot) en infra-scanning zitten bij veel teams in verschillende werelden. Breng ze samen in één overzicht.
  5. Meet en rapporteer. Gemiddelde tijd-tot-fix, aantal openstaande kritieke findings, trend over de maanden. Wat je meet, verbeter je — en wat je kunt laten zien, krijgt budget.

Volgende week: security auditing en technical risk assessment — de managementkant van beveiliging, en waarom "het staat in de policy" nog niet betekent "het gebeurt ook".