BIO 09.02 ISO A.8.1.1

DevSecOps: Beveiliging Integreren In De Ontwikkelketen Voor De Nederlandse Publieke Sector

📅 2025-01-27
•
⏱️ 35 minuten lezen
•
🔴 Must-Have

💼 Management Samenvatting

DevSecOps vormt de fundamentele transformatie waarbij beveiliging niet langer een aparte fase is aan het einde van de ontwikkelcyclus, maar een geïntegreerd onderdeel van elke stap in de softwareontwikkeling. Voor Nederlandse overheidsorganisaties betekent dit dat beveiligingscontroles, kwetsbaarheidsscans, secrets management en compliance-verificaties automatisch worden uitgevoerd binnen CI/CD-pipelines, waardoor kwetsbaarheden vroegtijdig worden gedetecteerd en verholpen voordat code in productie terechtkomt. Dit index-artikel schetst de overkoepelende DevSecOps-strategie, principes en implementatiebenaderingen die organisaties helpen om een volwassen, aantoonbaar beveiligde ontwikkelketen op te bouwen die voldoet aan de eisen van de Baseline Informatiebeveiliging Overheid (BIO), NIS2 richtlijn en andere relevante wet- en regelgeving.

Aanbeveling
IMPLEMENT
Risico zonder
High
Risk Score
9/10
Implementatie
280u (tech: 160u)
Van toepassing op:
✓ Azure DevOps
✓ GitHub Actions
✓ Azure Pipelines
✓ CI/CD
✓ Security Scanning
✓ Infrastructure as Code

Traditionele ontwikkelmethoden waarbij beveiliging pas aan het einde van het traject wordt meegenomen, leiden tot hoge kosten, vertragingen en verhoogde risico's. Nederlandse overheidsorganisaties die moderne cloudapplicaties ontwikkelen, worden geconfronteerd met complexe beveiligingsuitdagingen: kwetsbaarheden in broncode die pas tijdens een security review worden ontdekt, hardcoded credentials in repositories, onbeveiligde container images die naar productie worden gedeployed, en Infrastructure as Code configuraties die niet voldoen aan beveiligingsstandaarden. Zonder een geïntegreerde DevSecOps-aanpak ontstaan kwetsbare applicaties die niet voldoen aan compliance-vereisten, wat kan leiden tot datalekken, compromittering van systemen, niet-naleving van AVG en NIS2, bestuurlijke aansprakelijkheid en verlies van vertrouwen bij burgers. Een doordachte DevSecOps-strategie zorgt ervoor dat beveiliging vanaf het begin is ingebouwd in het ontwikkelingsproces, waardoor risico's en operationele kosten aanzienlijk worden verlaagd en releases sneller en veiliger kunnen plaatsvinden.

PowerShell Modules Vereist
Primary API: Azure DevOps REST API, GitHub API, Azure Resource Manager API
Connection: az devops login, Connect-AzAccount, gh auth login
Required Modules: Az.Accounts, Az.DevOps, Microsoft.Graph

Implementatie

Dit index-artikel positioneert DevSecOps binnen de "Nederlandse Baseline voor Veilige Cloud" en beschrijft hoe organisaties een samenhangend beveiligingslandschap kunnen opbouwen voor hun ontwikkel- en CI/CD-omgevingen. We behandelen fundamentele principes zoals shift-left security, security by design, geautomatiseerde security scanning (SAST, SCA, container scanning, IaC scanning), secrets management, security gates en approval workflows, en laten zien hoe deze worden vertaald naar concrete Azure DevOps, GitHub Actions of andere CI/CD-platform configuraties. Het artikel fungeert als kapstok voor meer specifieke artikelen over CI/CD security integration, secrets management, pipeline security, secure development lifecycle, container security en Infrastructure as Code security, en beschrijft hoe deze onderdelen samenkomen in een volwassen, aantoonbaar beveiligde DevSecOps-omgeving. Daarnaast biedt het artikel handvatten voor governance, compliance-monitoring, security metrics en periodieke evaluatie van de DevSecOps-volwassenheid.

Rol en scope van DevSecOps binnen de overheid

DevSecOps in een overheidscontext moet worden gezien als een strategische transformatie die technische beveiligingsmaatregelen, ontwikkelingsprocessen, compliance-vereisten en organisatorische cultuur met elkaar verbindt tot een samenhangend geheel. In tegenstelling tot traditionele benaderingen waarbij beveiliging achteraf wordt toegevoegd, vormt een doordachte DevSecOps-strategie de ruggengraat die ervoor zorgt dat alle componenten – van broncodebeheer tot deployment, van secrets management tot compliance-verificatie – op een consistente, beveiligde en beheersbare manier samenwerken. Deze strategie moet expliciet rekening houden met de specifieke eisen die gelden voor Nederlandse overheidsorganisaties, waaronder de Baseline Informatiebeveiliging Overheid (BIO), de NIS2 richtlijn, de Algemene Verordening Gegevensbescherming (AVG) en sectorale wetgeving zoals de Archiefwet.

De primaire rol van DevSecOps is het waarborgen van een veilige, betrouwbare en compliance-gerichte ontwikkelomgeving waarin organisaties software kunnen ontwikkelen, testen en deployen zonder onnodige risico's. Dit betekent dat beveiligingskeuzes niet alleen technisch correct moeten zijn, maar ook aantoonbaar moeten voldoen aan wettelijke en bestuurlijke vereisten. Een goed ontworpen DevSecOps-strategie maakt het mogelijk om te bewijzen dat passende maatregelen zijn genomen om broncode te beveiligen, dat kwetsbaarheden worden gescand en verholpen, dat secrets veilig worden beheerd, dat containers en infrastructure as code worden gevalideerd, en dat de organisatie in staat is om snel te reageren op beveiligingsincidenten in de development-omgeving. Voor auditors, toezichthouders en bestuurders biedt een gedocumenteerde DevSecOps-strategie transparantie over hoe beveiliging is ingericht en hoe deze wordt onderhouden.

De scope van DevSecOps binnen de Nederlandse Baseline voor Veilige Cloud omvat alle aspecten van de softwareontwikkelingslevenscyclus: van source code management en pull request workflows tot CI/CD-pipelines en deployment automation, van secrets management en toegangscontrole tot security scanning en compliance-verificatie. Het beveiligingslandschap moet rekening houden met verschillende ontwikkelingsscenario's – van traditionele waterfall-projecten tot agile en DevOps-teams, van monolithische applicaties tot microservices-architecturen, van on-premises ontwikkelomgevingen tot volledig cloud-native oplossingen – en moet schaalbaar zijn van kleine pilots tot grote organisaties met honderden ontwikkelaars en tientallen projecten. Daarnaast moet de DevSecOps-strategie flexibel genoeg zijn om te kunnen evolueren met nieuwe technologieën, CI/CD-platformen en veranderende ontwikkelingsmethodologieën, terwijl de fundamentele beveiligingsprincipes consistent blijven.

Shift-Left Security: Beveiliging vroeg in de ontwikkelcyclus

Het kernprincipe van DevSecOps is shift-left security: beveiliging wordt zo vroeg mogelijk in de ontwikkelingslevenscyclus geïntegreerd, waardoor kwetsbaarheden worden gedetecteerd en verholpen op het moment dat dit het minst kostbaar en meest effectief is. In plaats van te wachten tot een security review aan het einde van het project, worden beveiligingscontroles geautomatiseerd uitgevoerd tijdens het programmeren, bij elke commit, tijdens pull request reviews, en in elke fase van de CI/CD-pipeline. Dit betekent dat ontwikkelaars direct feedback krijgen over beveiligingsproblemen in hun code, waardoor zij deze kunnen oplossen terwijl de context nog vers is en de impact beperkt blijft tot een kleine wijziging in plaats van een grote refactoring.

Een volwassen shift-left implementatie begint bij de ontwikkelomgeving zelf. Integrated Development Environments (IDE's) worden uitgerust met plugins die real-time waarschuwingen geven over bekende kwetsbaarheidspatronen, onveilige API-gebruik en best practices voor veilige codering. Pre-commit hooks controleren code voordat deze wordt gecommit, waardoor hardcoded secrets, gevoelige data en onveilige configuraties worden tegengehouden voordat zij in de repository terechtkomen. Pull request workflows worden uitgebreid met geautomatiseerde security scans die Static Application Security Testing (SAST) uitvoeren op de gewijzigde code, waardoor ontwikkelaars en reviewers direct zien welke beveiligingsrisico's worden geïntroduceerd en kunnen beslissen of deze acceptabel zijn of eerst moeten worden opgelost.

In de CI/CD-pipeline worden meerdere beveiligingslagen geïntegreerd die parallel aan de build- en testprocessen draaien. Software Composition Analysis (SCA) scant alle afhankelijkheden en libraries op bekende kwetsbaarheden, waarbij automatisch pull requests worden gegenereerd om naar veilige versies te upgraden wanneer kritieke beveiligingslekken worden gevonden. Container image scanning controleert elke container die wordt gebouwd op kwetsbaarheden in de base image en geïnstalleerde packages, waarbij images met kritieke problemen worden geblokkeerd voor deployment. Infrastructure as Code (IaC) scanning valideert Terraform, Bicep of ARM templates op onveilige configuraties zoals publieke storage accounts, ontbrekende encryptie of te ruime netwerkregels. Dynamic Application Security Testing (DAST) en Interactive Application Security Testing (IAST) worden uitgevoerd in testomgevingen om runtime-beveiligingsproblemen te detecteren die niet zichtbaar zijn in statische code-analyse.

Security gates vormen een kritiek onderdeel van shift-left security door te voorkomen dat onveilige code of configuraties worden gedeployed naar productie. Deze gates evalueren de resultaten van alle security scans en blokkeren deployments wanneer kritieke of high-severity bevindingen worden gevonden. Gates kunnen worden geconfigureerd met verschillende policies: sommige organisaties blokkeren alle high-severity bevindingen, terwijl anderen een risicoscore gebruiken waarbij deployments worden geblokkeerd wanneer de totale risicoscore een drempelwaarde overschrijdt. Voor overheidsorganisaties is het belangrijk dat deze policies expliciet zijn gedocumenteerd en gekoppeld zijn aan compliance-vereisten, zodat tijdens audits kan worden aangetoond dat passende maatregelen zijn genomen om onveilige code te voorkomen.

Security Scanning Toolchain: SAST, SCA, Container en IaC Scanning

Een volwassen DevSecOps-omgeving combineert verschillende soorten security scanning tools die elk een specifiek aspect van de ontwikkelketen beveiligen. Static Application Security Testing (SAST) analyseert broncode zonder deze uit te voeren, waardoor kwetsbaarheden zoals SQL-injecties, cross-site scripting (XSS), onveilige authenticatie en autorisatie, en buffer overflows worden gedetecteerd voordat code wordt gedeployed. SAST-tools zoals Microsoft Defender for DevOps (voorheen GitHub Advanced Security), SonarQube, Checkmarx of Veracode worden geïntegreerd in CI/CD-pipelines om automatisch scans uit te voeren bij elke build, waarbij bevindingen worden gekoppeld aan specifieke code-regels en ontwikkelaars direct feedback krijgen. Voor Nederlandse overheidsorganisaties is het belangrijk dat SAST-tools worden geconfigureerd met rule sets die aansluiten bij OWASP Top 10, CWE Top 25 en specifieke compliance-vereisten uit BIO en NIS2.

Software Composition Analysis (SCA) richt zich op de afhankelijkheden en libraries die worden gebruikt in applicaties. Omdat moderne applicaties honderden of duizenden externe packages gebruiken, vormen kwetsbaarheden in deze dependencies een significant risico. SCA-tools zoals Snyk, WhiteSource, Dependabot of GitHub Dependabot scannen package manifesten (zoals package.json, requirements.txt, pom.xml of Gemfile) en vergelijken de gebruikte versies met kwetsbaarheidsdatabanken zoals de National Vulnerability Database (NVD) en advisories van package maintainers. Wanneer kritieke kwetsbaarheden worden gevonden, genereren deze tools automatisch pull requests om naar veilige versies te upgraden, waarbij ontwikkelaars kunnen zien welke functionaliteit mogelijk wordt beïnvloed door de upgrade. Voor overheidsorganisaties is het belangrijk dat SCA-scans regelmatig worden uitgevoerd (bijvoorbeeld dagelijks of bij elke build) en dat bevindingen worden gecorreleerd met compliance-vereisten, zodat kan worden aangetoond dat bekende kwetsbaarheden worden beheerd.

Container security scanning is essentieel omdat containers vaak worden gebouwd met base images die kwetsbaarheden bevatten, of omdat tijdens de build-processen onveilige packages worden geïnstalleerd. Tools zoals Trivy, Aqua Security, Snyk Container of Microsoft Defender for Containers scannen container images op kwetsbaarheden in het besturingssysteem, geïnstalleerde packages en applicatiecode. Daarnaast detecteren zij misconfiguraties zoals onnodig geopende poorten, hardcoded secrets, onveilige user permissions en niet-compliant base images. Container scanning wordt geïntegreerd in CI/CD-pipelines zodat images worden gescand voordat zij naar een container registry worden gepusht, waarbij images met kritieke kwetsbaarheden worden geblokkeerd. Voor overheidsorganisaties is het belangrijk dat container scanning policies expliciet zijn gedefinieerd, bijvoorbeeld dat alleen images zonder high of critical severity bevindingen mogen worden gedeployed, en dat scanresultaten worden vastgelegd voor audit doeleinden.

Infrastructure as Code (IaC) scanning valideert cloud-infrastructuur configuraties voordat deze worden gedeployed, waardoor misconfiguraties worden voorkomen die kunnen leiden tot beveiligingslekken. Tools zoals Checkov, Terrascan, tfsec of Azure Policy voor IaC analyseren Terraform, Bicep, ARM templates of CloudFormation configuraties op onveilige instellingen zoals publieke storage accounts, ontbrekende encryptie, te ruime netwerk security groups, ontbrekende logging of niet-compliant resource configuraties. IaC scanning wordt uitgevoerd als onderdeel van de CI/CD-pipeline voordat infrastructure changes worden gedeployed, waarbij templates met kritieke misconfiguraties worden geblokkeerd. Voor Nederlandse overheidsorganisaties is het belangrijk dat IaC scanning policies zijn afgestemd op de Nederlandse Baseline voor Veilige Cloud en specifieke BIO-vereisten, zodat infrastructure deployments automatisch voldoen aan beveiligingsstandaarden.

Secrets Management en Toegangscontrole

Een van de grootste beveiligingsrisico's in ontwikkelomgevingen is het onveilig beheren van secrets zoals API-keys, database credentials, certificaten en connection strings. Hardcoded secrets in broncode, configuratiebestanden of CI/CD-pipelines vormen een kritiek beveiligingslek omdat deze secrets zichtbaar zijn voor iedereen met toegang tot de repository en kunnen worden gecommit naar versiebeheersystemen waar zij permanent beschikbaar blijven, ook nadat de secrets zijn geroteerd. Een volwassen DevSecOps-strategie vereist daarom een gecentraliseerd secrets management systeem dat secrets veilig opslaat, versleutelt, roteert en audit logs bijhoudt.

Azure Key Vault vormt het centrale secrets management platform voor Azure-gebaseerde ontwikkelomgevingen, waarbij secrets, keys en certificates worden opgeslagen in een beveiligde, versleutelde omgeving met geïntegreerde toegangscontrole via Azure Active Directory. CI/CD-pipelines worden geconfigureerd om secrets uit Key Vault op te halen tijdens runtime in plaats van deze hardcoded op te slaan, waarbij managed identities worden gebruikt voor authenticatie zodat geen credentials nodig zijn in de pipeline-configuratie. Voor GitHub Actions of Azure DevOps worden secrets opgeslagen in de respectievelijke secrets management systemen (GitHub Secrets of Azure DevOps Variable Groups), waarbij secrets worden gekoppeld aan Key Vault via service connections. Secrets worden automatisch geroteerd volgens een vastgesteld schema, waarbij applicaties en pipelines automatisch de nieuwe versies gebruiken zonder handmatige interventie.

Secrets detection tools zoals GitGuardian, TruffleHog of GitHub Secret Scanning scannen repositories continu op hardcoded secrets, waarbij automatisch alerts worden gegenereerd wanneer secrets worden gedetecteerd. Deze tools gebruiken pattern matching en machine learning om verschillende soorten secrets te herkennen, zoals API keys, database credentials, cloud service account keys en tokens. Wanneer een secret wordt gevonden, wordt deze automatisch gemarkeerd in de repository, wordt de eigenaar geïnformeerd, en wordt het secret indien mogelijk automatisch geïnvalideerd bij de service provider. Voor overheidsorganisaties is het belangrijk dat secrets detection is geconfigureerd voor alle repositories, dat bevindingen worden geëscaleerd naar security teams, en dat incident response procedures zijn gedefinieerd voor wanneer secrets worden blootgesteld.

Toegangscontrole voor ontwikkelomgevingen moet gebaseerd zijn op het principe van least privilege, waarbij ontwikkelaars alleen toegang krijgen tot de resources en repositories die zij nodig hebben voor hun werk. Azure DevOps en GitHub bieden fine-grained toegangscontrole via role-based access control (RBAC), waarbij rollen zoals Contributor, Reader en Administrator worden toegewezen op project-, repository- of pipeline-niveau. Service connections en service principals worden gebruikt voor geautomatiseerde toegang, waarbij managed identities de voorkeur hebben boven service accounts met wachtwoorden. Toegangsrechten worden regelmatig gecontroleerd via access reviews, waarbij inactieve accounts worden gedeactiveerd en onnodige rechten worden ingetrokken. Voor overheidsorganisaties is het belangrijk dat toegangscontrole policies zijn gedocumenteerd, dat toegangsrechten worden gelogd voor audit doeleinden, en dat privileged access wordt beheerd via Privileged Identity Management (PIM) of Just-In-Time (JIT) toegang.

Implementatieroadmap: van basis naar volwassen DevSecOps

De implementatie van een volwassen DevSecOps-strategie verloopt zelden in één grote stap, maar groeit geleidelijk van een solide basis naar een geavanceerd, geoptimaliseerd landschap. In de eerste fase wordt de fundamentele basis gelegd: secrets management wordt geïmplementeerd met Azure Key Vault of een vergelijkbaar platform, basis security scanning wordt geïntegreerd in CI/CD-pipelines (bijvoorbeeld GitHub Dependabot voor dependency scanning), en toegangscontrole wordt gestandaardiseerd met duidelijke rollen en verantwoordelijkheden. Deze basislaag zorgt ervoor dat de meest kritieke beveiligingsrisico's worden aangepakt en dat er een fundament is waarop verder kan worden gebouwd.

In de volgende fase wordt de beveiligingsstrategie uitgebreid met geavanceerde security scanning en geautomatiseerde controles. SAST-tools worden geïntegreerd in pull request workflows, SCA-scans worden uitgevoerd bij elke build, container scanning wordt geactiveerd voor alle container images, en IaC scanning wordt toegevoegd voor infrastructure deployments. Security gates worden geconfigureerd om deployments te blokkeren wanneer kritieke bevindingen worden gevonden, waarbij policies worden gedefinieerd op basis van compliance-vereisten. Secrets detection wordt geactiveerd voor alle repositories, waarbij automatische alerts worden geconfigureerd. Monitoring en logging worden uitgebreid met Azure Monitor en Log Analytics voor centrale security monitoring en incident response in de ontwikkelomgeving.

In de volwassenheidsfase wordt de DevSecOps-strategie geoptimaliseerd en volledig geautomatiseerd. Security metrics en KPI's worden gedefinieerd en gemonitord, zoals het aantal gevonden kwetsbaarheden per release, de gemiddelde tijd tot remediatie, het percentage geautomatiseerde security tests, en de compliance-score van ontwikkelomgevingen. Geautomatiseerde remediatie wordt geïmplementeerd voor veelvoorkomende beveiligingsproblemen, waarbij scripts automatisch fixes toepassen wanneer mogelijk. Advanced threat protection, behavioral analytics en machine learning-gebaseerde detectie helpen om verdachte activiteiten in repositories en pipelines vroegtijdig te identificeren. Governance wordt volwassen met geautomatiseerde rapportages, dashboards voor bestuurders en geïntegreerde change management processen. Door deze fasering expliciet te maken in een roadmap – met duidelijke mijlpalen, beslismomenten en success criteria – ontstaat voorspelbaarheid voor bestuurders en wordt het eenvoudiger om investeringen, risico's en baten te verantwoorden.

Governance, compliance en relatie met andere artikelen

Governance rond DevSecOps raakt meerdere disciplines: informatiebeveiliging, software development lifecycle management, cloud governance, compliance en risk management. Zonder een helder governance-model ontstaat het risico dat beveiligingskeuzes versnipperd worden gemaakt, dat verschillende teams verschillende standaarden hanteren, en dat niemand zich eigenaar voelt van de integrale DevSecOps-strategie. Een effectief governance-model benoemt daarom ten minste een DevSecOps architect die verantwoordelijk is voor de overkoepelende beveiligingsstrategie, een security officer die beveiligingsaspecten waarborgt, en expliciete rollen voor CISO, privacy officer en compliance officer. Deze rollen worden vertaald naar concrete taken: wie keurt nieuwe beveiligingspatronen goed, wie beoordeelt afwijkingen van standaarden, wie beheert de beveiligingsdocumentatie, en wie beslist over het uitfaseren van verouderde beveiligingsmaatregelen. Deze afspraken worden vastgelegd in governance-documenten, beveiligingsprincipes en changeprocedures zodat zij organisatiebreed herkenbaar zijn.

Op compliancegebied vormt DevSecOps een kruispunt van verschillende wettelijke kaders. De AVG vereist dat persoonsgegevens adequaat worden beveiligd en dat organisaties kunnen aantonen welke technische en organisatorische maatregelen zijn genomen, ook in development-omgevingen. De BIO en NIS2 leggen eisen op rond informatiebeveiliging, incident response en continuïteit, waarbij development-omgevingen vaak kritieke systemen zijn die moeten worden beschermd. ISO 27001 biedt een internationaal erkend framework voor informatiebeveiligingsmanagement, inclusief beveiliging van development-omgevingen. Deze compliance-vereisten moeten expliciet worden vertaald naar beveiligingskeuzes: welke security scanning tools worden gebruikt, hoe worden secrets beheerd, hoe worden toegangsrechten gecontroleerd, hoe worden logs bewaard, en hoe wordt incident response georganiseerd voor development-omgevingen. Dit index-artikel moet daarom expliciet worden gelezen in samenhang met andere artikelen binnen de "Nederlandse Baseline voor Veilige Cloud", zoals de artikelen over CI/CD security integration, secrets management, pipeline security, secure development lifecycle, container security en Infrastructure as Code security. Samen vormen zij een consistent raamwerk: dit artikel schetst de overkoepelende lijnen, terwijl de deelartikelen verdieping bieden op specifieke beveiligingsaspecten en technische implementaties.

Voor auditors en toezichthouders is vooral van belang dat de samenhang tussen beleid, beveiligingsstrategie, implementatie en operationele controles aantoonbaar is. Dat betekent dat u niet alleen beveiligingsdocumenten en procesbeschrijvingen beschikbaar heeft, maar ook concreet kunt laten zien welke security scanning tools zijn geconfigureerd, hoe vaak scans worden uitgevoerd, welke bevindingen zijn gevonden en verholpen, hoe secrets worden beheerd, en welke verbeteracties zijn ondernomen na incidenten of bevindingen. De in dit domein beschreven PowerShell-scripts – waaronder het index-script bij dit artikel en de scripts voor specifieke DevSecOps-componenten – helpen om deze informatie snel en reproduceerbaar te verzamelen. Door hun output te koppelen aan dashboards en rapportages wordt governance niet beperkt tot papieren documenten, maar ondersteund door actuele operationele data die aantoonbaar maakt dat de DevSecOps-strategie daadwerkelijk wordt nageleefd en onderhouden.

Monitoring van het DevSecOps-beveiligingslandschap

Gebruik PowerShell-script index.ps1 (functie Invoke-Monitoring) – Geeft een overzicht van de belangrijkste DevSecOps-beveiligingscomponenten en controleert of basiselementen aanwezig en correct geconfigureerd zijn..

Monitoring van het DevSecOps-beveiligingslandschap gaat verder dan het bewaken van individuele repositories of pipelines. Bestuurders, security teams en compliance officers hebben behoefte aan een samenvattend beeld: welke security scanning tools zijn geconfigureerd, hoeveel kwetsbaarheden worden gevonden en verholpen, hoe worden secrets beheerd, welke security gates zijn actief, en zijn er signalen dat de beveiligingsstrategie niet meer voldoet aan compliance-vereisten. Het index-script bij dit artikel inventariseert de belangrijkste DevSecOps-beveiligingscomponenten en vertaalt die naar een compacte managementsamenvatting: hoeveel repositories hebben security scanning geconfigureerd, hoeveel pipelines hebben security gates, welke secrets management-oplossingen zijn actief, en voor welke onderdelen aanvullende acties nodig zijn. Dit vormt een startpunt voor diepgaandere analyses met gespecialiseerde scripts voor specifieke DevSecOps-beveiligingscomponenten, en helpt om het gesprek met bestuur en auditcommissies te structureren rond feitelijke cijfers en meetbare beveiligingsvolwassenheid.

Effectieve DevSecOps-beveiligingsmonitoring omvat zowel technische als governance-aspecten. Technisch gezien moet worden gemonitord of security scanning tools correct zijn geconfigureerd en regelmatig worden uitgevoerd, of pipelines security gates bevatten, of secrets veilig worden beheerd, of container images worden gescand, en of er afwijkingen zijn die kunnen wijzen op security risico's of compliance-problemen. Governance-monitoring richt zich op de vraag of beveiligingsprincipes worden nageleefd, of documentatie actueel is, of change management processen correct worden gevolgd, en of er regelmatige reviews plaatsvinden om de beveiligingsstrategie te evalueren en te verbeteren. Door beide aspecten te combineren ontstaat een compleet beeld van de DevSecOps-beveiligingsvolwassenheid en kunnen gerichte verbeteracties worden ondernomen om de beveiligingsstrategie verder te professionaliseren.

Remediatie en volwassenwording van DevSecOps-beveiliging

Gebruik PowerShell-script index.ps1 (functie Invoke-Remediation) – Genereert overzichten van DevSecOps-beveiligingshiaten en biedt handvatten voor gerichte verbeteracties om de beveiligingsvolwassenheid te verhogen..

Remediatie binnen het DevSecOps-beveiligingsdomein betekent in de praktijk dat u gaten dicht tussen de gewenste beveiligingsstrategie en de werkelijkheid. In veel organisaties bestaan al wel beleidsdocumenten over softwareontwikkeling, informatiebeveiliging en DevSecOps-beveiligingsprincipes, maar ontbreekt concrete vastlegging van hoe deze worden vertaald naar CI/CD-configuraties, welke beveiligingsmaatregelen daadwerkelijk zijn ingericht, en hoe de beveiligingsstrategie wordt onderhouden en geëvalueerd. Het index-script ondersteunt remediatie door automatisch te inventariseren waar beveiligingsstandaarden niet worden nageleefd, waar beveiligingsmaatregelen ontbreken, en waar documentatie verouderd of incompleet is. Op basis van deze inventarisatie kunnen gerichte verbeteracties worden gepland en uitgevoerd, waarbij prioriteit wordt gegeven aan de meest kritieke hiaten die de grootste impact hebben op beveiliging en compliance.

Een volwassen DevSecOps-beveiligingsstrategie groeit stap voor stap door continue verbetering. Na elke monitoringsronde worden de belangrijkste verbeterpunten vastgelegd, van een eigenaar voorzien en ingepland in het reguliere change- of verbeterportfolio. Denk aan het implementeren van ontbrekende security scanning tools, het configureren van security gates in pipelines, het verbeteren van secrets management door migratie naar Azure Key Vault, het actualiseren van beveiligingsdocumentatie of het invoeren van geautomatiseerde compliance-controles. Door de resultaten van het index-script te combineren met de uitkomsten van gespecialiseerde scripts voor specifieke DevSecOps-beveiligingscomponenten ontstaat een integraal beeld van de voortgang. Uiteindelijk wordt DevSecOps-beveiliging zo niet alleen een technisch ontwerp, maar een aantoonbaar beheerst en verantwoord ingericht fundament voor de softwareontwikkeling van de organisatie, dat continu wordt geëvalueerd en verbeterd om te blijven voldoen aan veranderende eisen en dreigingen.

Compliance & Frameworks

Automation

Gebruik het onderstaande PowerShell script om deze security control te monitoren en te implementeren. Het script bevat functies voor zowel monitoring (-Monitoring) als remediation (-Remediation).

PowerShell
<# .SYNOPSIS Overzichtsmonitoring en remediatie voor DevSecOps-beveiligingslandschap .DESCRIPTION Geeft een samenvattend beeld van de belangrijkste DevSecOps-beveiligingscomponenten (security scanning tools, secrets management, security gates, CI/CD-pipelines en beveiligingsconfiguraties) binnen de repository en ondersteunt het gericht dichten van hiaten in beveiligingsstandaarden en configuratieregisters. .NOTES Filename: index.ps1 Author: Nederlandse Baseline voor Veilige Cloud Created: 2025-01-27 Last Modified: 2025-01-27 Version: 1.0 Related JSON: content/azure/devsecops/index.json .LINK https://github.com/[org]/m365-tenant-best-practise .EXAMPLE .\index.ps1 -Monitoring Toont een samenvattend overzicht van DevSecOps-beveiligingscomponenten en configuratiestatus. .EXAMPLE .\index.ps1 -Remediation Genereert een basisoverzicht en, indien gewenst, templates voor ontbrekende beveiligingsdocumentatie. #> #Requires -Version 5.1 #Requires -Modules Az.Accounts, Az.DevOps [CmdletBinding()] param( [Parameter(HelpMessage = "Voer een samenvattende monitoring uit van het DevSecOps-beveiligingslandschap.")] [switch]$Monitoring, [Parameter(HelpMessage = "Genereer remediatie-overzichten en optioneel documentatietemplates.")] [switch]$Remediation, [Parameter(HelpMessage = "Toon welke acties zouden worden uitgevoerd zonder daadwerkelijk te wijzigen.")] [switch]$WhatIf ) $ErrorActionPreference = 'Stop' $VerbosePreference = 'Continue' function Get-RepositoryRoot { <# .SYNOPSIS Bepaalt de rootmap van de repository op basis van de locatie van dit script. .OUTPUTS String met pad naar repository-root. #> [CmdletBinding()] param() $root = Resolve-Path (Join-Path $PSScriptRoot "..\..\..") -ErrorAction SilentlyContinue if (-not $root) { throw "Kon de repository-root niet bepalen op basis van PSScriptRoot: $PSScriptRoot" } return $root.Path } function Get-DevSecOpsSecurityInventory { <# .SYNOPSIS Stelt een overzicht op van DevSecOps-beveiligings-gerelateerde JSON- en PS1-bestanden. .OUTPUTS PSCustomObject met aantallen en details. #> [CmdletBinding()] param() $repoRoot = Get-RepositoryRoot $contentRoot = Join-Path $repoRoot "content\azure\devsecops" $codeRoot = Join-Path $repoRoot "code\azure\devsecops" $jsonFiles = @() if (Test-Path -Path $contentRoot) { $jsonFiles = Get-ChildItem -Path $contentRoot -Filter "*.json" -File -ErrorAction SilentlyContinue } $ps1Files = @() if (Test-Path -Path $codeRoot) { $ps1Files = Get-ChildItem -Path $codeRoot -Filter "*.ps1" -File -ErrorAction SilentlyContinue } $byName = @{} foreach ($json in $jsonFiles) { $base = [System.IO.Path]::GetFileNameWithoutExtension($json.Name) if (-not $byName.ContainsKey($base)) { $byName[$base] = [pscustomobject]@{ Name = $base JsonPath = $null JsonUpdated = $null ScriptPath = $null ScriptUpdated= $null } } $entry = $byName[$base] $entry.JsonPath = $json.FullName $entry.JsonUpdated = $json.LastWriteTime $byName[$base] = $entry } foreach ($ps1 in $ps1Files) { $base = [System.IO.Path]::GetFileNameWithoutExtension($ps1.Name) if (-not $byName.ContainsKey($base)) { $byName[$base] = [pscustomobject]@{ Name = $base JsonPath = $null JsonUpdated = $null ScriptPath = $null ScriptUpdated= $null } } $entry = $byName[$base] $entry.ScriptPath = $ps1.FullName $entry.ScriptUpdated = $ps1.LastWriteTime $byName[$base] = $entry } $items = $byName.Values | Sort-Object Name $missingJson = $items | Where-Object { -not $_.JsonPath } $missingScript = $items | Where-Object { -not $_.ScriptPath } return [pscustomobject]@{ RepositoryRoot = $repoRoot Items = $items MissingJson = $missingJson MissingScripts = $missingScript TotalControls = $items.Count WithJsonAndPs1 = ($items | Where-Object { $_.JsonPath -and $_.ScriptPath }).Count } } function Test-DevSecOpsConnection { <# .SYNOPSIS Controleert of er een actieve verbinding bestaat met Azure DevOps of GitHub. .OUTPUTS Boolean: $true als verbonden, anders $false #> [CmdletBinding()] param() try { # Controleer of Azure DevOps CLI is geïnstalleerd en geconfigureerd $azDevOpsCheck = az devops --version 2>$null if ($LASTEXITCODE -eq 0) { Write-Verbose "Azure DevOps CLI beschikbaar" # Probeer een eenvoudige query uit te voeren $orgs = az devops organization list 2>$null | ConvertFrom-Json -ErrorAction SilentlyContinue if ($orgs) { Write-Verbose "Azure DevOps-verbinding actief" return $true } } # Controleer of GitHub CLI is geïnstalleerd $ghCheck = gh --version 2>$null if ($LASTEXITCODE -eq 0) { Write-Verbose "GitHub CLI beschikbaar" $ghAuth = gh auth status 2>$null if ($LASTEXITCODE -eq 0) { Write-Verbose "GitHub-verbinding actief" return $true } } return $false } catch { Write-Verbose "Geen actieve DevSecOps-platform verbinding: $_" return $false } } function Get-DevSecOpsSecurityStatus { <# .SYNOPSIS Inventariseert de status van belangrijke DevSecOps-beveiligingscomponenten. .OUTPUTS PSCustomObject met beveiligingsstatus. #> [CmdletBinding()] param() $isConnected = Test-DevSecOpsConnection if (-not $isConnected) { Write-Warning "Geen actieve Azure DevOps of GitHub-verbinding. Alleen repository-inventarisatie wordt uitgevoerd." return [pscustomobject]@{ PlatformConnected = $false Organizations = 0 Repositories = 0 Pipelines = 0 SecurityScansConfigured = 0 SecretsManagementConfigured = 0 } } try { Write-Verbose "Inventariseren van DevSecOps-beveiligingscomponenten..." $organizations = @() $repositories = @() $pipelines = @() # Probeer Azure DevOps try { $orgsJson = az devops organization list 2>$null | ConvertFrom-Json -ErrorAction SilentlyContinue if ($orgsJson) { $organizations = $orgsJson } } catch { Write-Verbose "Kon Azure DevOps organisaties niet ophalen: $_" } # Probeer GitHub try { $ghRepos = gh repo list --limit 10 2>$null | ConvertFrom-Json -ErrorAction SilentlyContinue if ($ghRepos) { $repositories = $ghRepos } } catch { Write-Verbose "Kon GitHub repositories niet ophalen: $_" } # Voor een volledige inventarisatie zouden we per organisatie/project repositories en pipelines moeten ophalen # Dit is een vereenvoudigde versie die de structuur toont return [pscustomobject]@{ PlatformConnected = $true Organizations = $organizations.Count Repositories = $repositories.Count Pipelines = $pipelines.Count SecurityScansConfigured = 0 # Vereist per-repository query SecretsManagementConfigured = 0 # Vereist per-repository query } } catch { Write-Warning "Fout bij inventariseren van DevSecOps-componenten: $_" return [pscustomobject]@{ PlatformConnected = $false Organizations = 0 Repositories = 0 Pipelines = 0 SecurityScansConfigured = 0 SecretsManagementConfigured = 0 } } } function New-DevSecOpsSecurityDocumentationTemplate { <# .SYNOPSIS Maakt een eenvoudige Markdown-template aan voor aanvullende DevSecOps-beveiligingsdocumentatie. #> [CmdletBinding()] param( [Parameter(Mandatory = $true)] [string]$Name, [Parameter(Mandatory = $true)] [string]$OutputPath ) $template = @" # DevSecOps Beveiliging component: $Name **Laatst bijgewerkt:** $(Get-Date -Format "yyyy-MM-dd") **Documentatie-eigenaar:** [Naam / functie] **Status:** Concept ## 1. Rol in het DevSecOps-beveiligingslandschap [Beschrijf hoe deze component (artikel, script of control) past in de totale DevSecOps-beveiligingsstrategie.] ## 2. Beveiligingsprincipes en best practices [Beschrijf welke beveiligingsprincipes en best practices worden toegepast, zoals shift-left security, security by design, en geautomatiseerde security scanning.] ## 3. Technische implementatie [Beschrijf de concrete CI/CD-configuraties, security scanning tools, secrets management en security gates.] ## 4. Security Scanning en Tools [Beschrijf welke SAST, SCA, container scanning en IaC scanning tools worden gebruikt en hoe deze zijn geconfigureerd.] ## 5. Secrets Management [Beschrijf hoe secrets worden beheerd, bijvoorbeeld via Azure Key Vault, GitHub Secrets of Azure DevOps Variable Groups.] ## 6. Security Gates en Approval Workflows [Beschrijf hoe security gates zijn geconfigureerd om onveilige code of configuraties te blokkeren.] ## 7. Compliance en governance [Beschrijf hoe wordt voldaan aan BIO, NIS2, AVG en andere relevante kaders.] ## 8. Verbeterpunten en vervolgstappen [Beschrijf bekende verbeterpunten, gepland onderhoud en evaluatiemomenten.] "@ $folder = Split-Path -Path $OutputPath -Parent if (-not (Test-Path -Path $folder)) { New-Item -Path $folder -ItemType Directory -Force | Out-Null } $template | Out-File -FilePath $OutputPath -Encoding UTF8 Write-Host " Template gegenereerd: $OutputPath" -ForegroundColor Green } function Invoke-Monitoring { <# .SYNOPSIS Voert een samenvattende monitoring uit van DevSecOps-beveiligingscomponenten. .OUTPUTS PSCustomObject met overzichtsresultaten. #> [CmdletBinding()] param() Write-Host "`nMonitoring: DevSecOps Beveiliging overzicht" -ForegroundColor Yellow Write-Host "=============================================" -ForegroundColor Yellow $inventory = Get-DevSecOpsSecurityInventory $devsecopsStatus = Get-DevSecOpsSecurityStatus Write-Host "`nRepository-root: $($inventory.RepositoryRoot)" -ForegroundColor Cyan Write-Host "Totaal DevSecOps-beveiligingscontrols (JSON/PS1-combinaties): $($inventory.TotalControls)" -ForegroundColor Cyan Write-Host "Volledig gekoppeld (JSON + PS1): $($inventory.WithJsonAndPs1)" -ForegroundColor Cyan if ($devsecopsStatus.PlatformConnected) { Write-Host "`nDevSecOps-platform status:" -ForegroundColor Cyan Write-Host " Organisaties: $($devsecopsStatus.Organizations)" -ForegroundColor Gray Write-Host " Repositories: $($devsecopsStatus.Repositories)" -ForegroundColor Gray Write-Host " Pipelines: $($devsecopsStatus.Pipelines)" -ForegroundColor Gray Write-Host " Security scans geconfigureerd: $($devsecopsStatus.SecurityScansConfigured)" -ForegroundColor Gray Write-Host " Secrets management geconfigureerd: $($devsecopsStatus.SecretsManagementConfigured)" -ForegroundColor Gray } else { Write-Host "`n⚠️ Geen actieve Azure DevOps of GitHub-verbinding. Configureer Azure DevOps CLI of GitHub CLI voor volledige monitoring." -ForegroundColor Yellow Write-Host " Azure DevOps: az extension add --name azure-devops" -ForegroundColor Gray Write-Host " Azure DevOps: az devops configure --defaults organization=https://dev.azure.com/YOURORG" -ForegroundColor Gray Write-Host " GitHub: gh auth login" -ForegroundColor Gray } if ($inventory.MissingJson.Count -gt 0) { Write-Host "`n❌ Ontbrekende JSON voor de volgende scripts:" -ForegroundColor Red foreach ($item in $inventory.MissingJson) { Write-Host " - $($item.Name) (script: $($item.ScriptPath))" -ForegroundColor Red } } if ($inventory.MissingScripts.Count -gt 0) { Write-Host "`n❌ Ontbrekende PS1-scripts voor de volgende JSON-bestanden:" -ForegroundColor Red foreach ($item in $inventory.MissingScripts) { Write-Host " - $($item.Name) (json: $($item.JsonPath))" -ForegroundColor Red } } if (($inventory.MissingJson.Count -eq 0) -and ($inventory.MissingScripts.Count -eq 0)) { Write-Host "`n✅ Alle DevSecOps-beveiligingsartikelen hebben zowel JSON als PS1." -ForegroundColor Green } else { Write-Host "`n⚠️ Er zijn nog hiaten in de JSON/PS1-koppeling voor DevSecOps-beveiliging." -ForegroundColor Yellow Write-Host " Gebruik -Remediation om gericht met deze hiaten aan de slag te gaan." -ForegroundColor Yellow } return [pscustomobject]@{ Inventory = $inventory DevSecOpsStatus = $devsecopsStatus } } function Invoke-Remediation { <# .SYNOPSIS Ondersteunt remediatie door ontbrekende componenten inzichtelijk te maken en optioneel documentatietemplates te genereren. .OUTPUTS PSCustomObject met remediatieadvies. #> [CmdletBinding()] param() Write-Host "`nRemediatie: DevSecOps Beveiliging overzicht" -ForegroundColor Yellow Write-Host "=============================================" -ForegroundColor Yellow $inventory = Get-DevSecOpsSecurityInventory $repoRoot = $inventory.RepositoryRoot $docRoot = Join-Path $repoRoot "documentatie\devsecops-security" if (-not (Test-Path -Path $docRoot)) { New-Item -Path $docRoot -ItemType Directory -Force | Out-Null } $actions = @() foreach ($item in $inventory.Items) { $action = [pscustomobject]@{ Name = $item.Name HasJson = [bool]$item.JsonPath HasScript = [bool]$item.ScriptPath DocumentationPath = $null DocumentationExists = $false } $docFile = Join-Path $docRoot ("devsecops-sec-" + $item.Name + ".md") $action.DocumentationPath = $docFile $action.DocumentationExists = Test-Path -Path $docFile if (-not $action.DocumentationExists -and -not $WhatIf) { New-DevSecOpsSecurityDocumentationTemplate -Name $item.Name -OutputPath $docFile } elseif (-not $action.DocumentationExists -and $WhatIf) { Write-Host " [WhatIf] Zou documentatietemplate aanmaken: $docFile" -ForegroundColor Yellow } $actions += $action } Write-Host "`nSamenvatting remediatie-status:" -ForegroundColor Cyan Write-Host (" Items zonder JSON: {0}" -f ($actions | Where-Object { -not $_.HasJson }).Count) -ForegroundColor Cyan Write-Host (" Items zonder script: {0}" -f ($actions | Where-Object { -not $_.HasScript }).Count) -ForegroundColor Cyan Write-Host (" Items zonder documentatie: {0}" -f ($actions | Where-Object { -not $_.DocumentationExists }).Count) -ForegroundColor Cyan return $actions } try { Write-Host "`n========================================" -ForegroundColor Cyan Write-Host "DevSecOps Beveiliging Overzichtsmonitor" -ForegroundColor Cyan Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan Write-Host "========================================`n" -ForegroundColor Cyan if ($Monitoring) { Invoke-Monitoring | Out-Null } elseif ($Remediation) { Invoke-Remediation | Out-Null } else { # Standaard: compacte compliance check via monitoring $result = Invoke-Monitoring if (($result.Inventory.MissingJson.Count -eq 0) -and ($result.Inventory.MissingScripts.Count -eq 0)) { Write-Host "`n✅ COMPLIANT" -ForegroundColor Green } else { Write-Host "`n❌ NON-COMPLIANT" -ForegroundColor Red Write-Host "Run met -Remediation voor een gericht overzicht van hiaten en documentatietemplates." -ForegroundColor Yellow } } } catch { Write-Error "Er is een fout opgetreden in index.ps1: $_" throw } finally { Write-Host "`n========================================`n" -ForegroundColor Cyan }

Risico zonder implementatie

Risico zonder implementatie
High: Zonder een doordachte DevSecOps-strategie ontstaan kwetsbare development-omgevingen waarin kwetsbaarheden pas laat worden gedetecteerd, hardcoded secrets in repositories terechtkomen, onveilige containers en infrastructure configuraties worden gedeployed, en CI/CD-pipelines geen beveiligingscontroles bevatten. Dit kan leiden tot datalekken, compromittering van productiesystemen, niet-naleving van AVG, BIO en NIS2, bestuurlijke aansprakelijkheid en verlies van vertrouwen bij burgers en bestuurders.

Management Samenvatting

Een doordachte DevSecOps-strategie vormt de fundamentele basis voor veilige, betrouwbare en compliance-gerichte ontwikkelomgevingen binnen de Nederlandse publieke sector. Dit index-artikel schetst de overkoepelende beveiligingsprincipes, best practices en implementatiestrategieën, en fungeert als kapstok voor meer specifieke artikelen over CI/CD security integration, secrets management, pipeline security, container security en Infrastructure as Code security.