BIO 09.01 ISO A.8.1.1

Secure Development Lifecycle Voor Azure DevOps

📅 2025-01-15
•
⏱️ 30 minuten lezen
•
🔴 Must-Have

💼 Management Samenvatting

Een Secure Development Lifecycle (SDLC) integreert beveiliging structureel in elke fase van de softwareontwikkeling, van initiatie tot en met buitengebruikstelling. Voor Nederlandse overheidsorganisaties die werken met Azure DevOps is een robuuste SDLC essentieel om te borgen dat applicaties en services vanaf het eerste ontwerp veilig zijn en blijven voldoen aan eisen vanuit BIO, NIS2 en andere relevante kaders.

Aanbeveling
IMPLEMENT
Risico zonder
High
Risk Score
9/10
Implementatie
360u (tech: 200u)
Van toepassing op:
✓ Azure DevOps
✓ GitHub Actions
✓ Azure Pipelines
✓ CI/CD
✓ DevSecOps

Zonder een gestructureerde Secure Development Lifecycle ontstaat er een patroon van ad-hoc beveiligingsmaatregelen die vooral reactief zijn: kwetsbaarheden worden pas ontdekt na penetratietesten, audits of – erger nog – na een beveiligingsincident. Ontwikkelteams voelen druk om snel functionaliteit op te leveren en schuiven security-werkzaamheden voor zich uit, waardoor bekende OWASP Top 10-risico's zoals SQL-injectie, broken access control, onveilige authenticatie en blootgestelde API's in productie terechtkomen. In Azure DevOps-omgevingen zien auditors regelmatig code met hardcoded secrets, niet-gevalideerde gebruikersinput die direct wordt doorgestuurd naar databases of achterliggende API's, onvoldoende foutafhandeling waardoor interne systeeminformatie in foutmeldingen zichtbaar wordt, en een gebrek aan structurele security reviews in het ontwikkelproces. Dit leidt tot een onoverzichtelijk risico-profiel: er is geen aantoonbare lijn tussen ontwerpbeslissingen, threat modeling, codekwaliteit, testresultaten en de configuratie van de productie-omgeving. Voor organisaties die moeten voldoen aan BIO, NIS2 en ISO 27001 is dit onhoudbaar; deze kaders vereisen expliciet dat beveiliging integraal onderdeel is van de levenscyclus van informatiesystemen en dat keuzes aantoonbaar zijn gedocumenteerd en beoordeeld.

PowerShell Modules Vereist
Primary API: Azure DevOps REST API, Azure Resource Manager API
Connection: Connect-AzAccount, az login
Required Modules: Az.Accounts, Az.Resources

Implementatie

Dit artikel beschrijft een compleet raamwerk voor een Secure Development Lifecycle specifiek gericht op Azure DevOps-omgevingen binnen de context van de Nederlandse Baseline voor Veilige Cloud. Het raamwerk combineert procesmatige maatregelen (zoals het inrichten van een SDLC met vaste security gates), praktische technische maatregelen (zoals het standaard uitvoeren van threat modeling, statische code-analyse, dependency scanning, secret scanning en automatische beveiligingstesten in CI/CD pipelines), en organisatorische maatregelen (zoals het definiëren van duidelijke rollen en verantwoordelijkheden, het trainen van ontwikkelaars en het vastleggen van beslissingen in een security-architectuurdossier). Aan de hand van concrete stappen wordt uitgewerkt hoe organisaties threat modeling structureel kunnen toepassen bij nieuwe functionaliteiten, hoe code reviews worden uitgebreid met security-checklists, hoe open-source componenten en libraries continu op kwetsbaarheden worden gecontroleerd, en hoe bevindingen uit tooling worden vertaald naar verbeteracties met duidelijke prioriteiten. Bovendien wordt beschreven hoe deze SDLC aansluit op andere maatregelen in de Nederlandse Baseline voor Veilige Cloud, zoals secrets management, logging en monitoring, en compliance-rapportage. Het artikel bevat een PowerShell-script dat Azure DevOps-projecten inventariseert en rapporteert of basisvoorwaarden voor secure development – zoals security gates in pipelines, threat modeling documentatie en security training – aanwezig zijn, zodat security- en ontwikkelteams gericht kunnen verbeteren.

Fundament van een Secure Development Lifecycle

Een Secure Development Lifecycle is geen losstaand project, maar een permanent raamwerk dat bepaalt hoe software binnen de organisatie wordt ontworpen, gebouwd, getest en beheerd. Voor Azure DevOps betekent dit dat elke applicatie en service – van idee tot productie – dezelfde beveiligingsstappen doorloopt. De basis begint bij een formeel vastgelegd SDLC-proces waarin security expliciet is opgenomen als onderdeel van elke fase: initiatie, ontwerp, ontwikkeling, testen, implementatie en beheer. Dit proces wordt beschreven in beleid en werkinstructies, zodat ontwikkelaars, product owners, security officers en beheerders exact weten welke beveiligingsacties op welk moment verplicht zijn. Het voorkomt dat security wordt gezien als een optionele controle "aan het einde", en borgt dat risico's vroegtijdig worden geïdentificeerd en gemitigeerd wanneer de kosten en impact nog relatief laag zijn.

De SDLC-fases worden ondersteund door duidelijke security gates: checkpoints waar specifieke beveiligingsvereisten moeten zijn voldaan voordat een project naar de volgende fase kan. In de initiatiefase wordt bijvoorbeeld een eerste risico-inschatting gemaakt en wordt bepaald of threat modeling verplicht is. In de ontwerpfase worden security-architectuurprincipes toegepast, worden threat models opgesteld en worden security-vereisten gedefinieerd. In de ontwikkelfase worden secure coding-standaarden gevolgd, worden code reviews uitgevoerd met security-focus, en worden automatische security-scans uitgevoerd. In de testfase worden beveiligingstesten uitgevoerd, inclusief penetration testing voor kritieke applicaties. In de implementatiefase worden security-configuraties gecontroleerd en worden deployment-procedures gevolgd. En in de beheerfase worden security-updates toegepast, worden incidenten afgehandeld en worden periodieke security-assessments uitgevoerd. Door deze gates expliciet te definiëren en technisch af te dwingen waar mogelijk (bijvoorbeeld via Azure DevOps pipeline gates), wordt voorkomen dat projecten security-stappen overslaan.

Threat modeling is een kernactiviteit in de SDLC die helpt om beveiligingsrisico's vroegtijdig te identificeren en te mitigeren. Bij threat modeling wordt systematisch geanalyseerd welke bedreigingen relevant zijn voor een applicatie of service, welke aanvalsvectoren bestaan, en welke mitigatiemaatregelen nodig zijn. Voor Azure DevOps-projecten betekent dit dat bij het ontwerp van nieuwe functionaliteit expliciet wordt nagedacht over authenticatie en autorisatie, data protection, input validation, error handling, logging en monitoring. Threat models worden vastgelegd in gestandaardiseerde templates en worden periodiek herzien wanneer de applicatie of de threat landscape verandert. Tools zoals Microsoft Threat Modeling Tool of OWASP Threat Dragon kunnen worden gebruikt om threat modeling te structureren en te documenteren. Door threat modeling structureel toe te passen, kunnen ontwikkelteams proactief beveiligingsmaatregelen inbouwen in plaats van reactief te reageren op incidenten.

Secure coding-standaarden vormen de basis voor veilige softwareontwikkeling. Deze standaarden beschrijven concrete richtlijnen voor het schrijven van veilige code, zoals het gebruik van parameterized queries om SQL-injectie te voorkomen, het valideren en sanitizen van alle gebruikersinput, het gebruik van veilige authenticatie- en autorisatiemechanismen, en het voorkomen van informatie disclosure in foutmeldingen. Voor Azure DevOps-projecten worden deze standaarden vertaald naar concrete coding guidelines per programmeertaal (C#, JavaScript, Python, Java, etc.) en worden ze geïntegreerd in development tools zoals linters, code analyzers en IDE-plugins. Code reviews worden uitgebreid met security-checklists die controleren of secure coding-standaarden zijn gevolgd. Door deze standaarden expliciet te definiëren en te trainen, kunnen ontwikkelteams consistente, veilige code schrijven die voldoet aan organisatiebrede beveiligingsvereisten.

Security Gates in CI/CD Pipelines

Security gates in CI/CD pipelines zijn geautomatiseerde controles die ervoor zorgen dat alleen code die voldoet aan beveiligingsvereisten kan worden uitgerold naar productie. Deze gates worden geïmplementeerd als verplichte stappen in Azure DevOps pipelines, waarbij de pipeline automatisch faalt wanneer een gate niet wordt gepasseerd. Typische security gates omvatten statische code-analyse (SAST) om kwetsbaarheden in code te detecteren, dependency scanning om bekende kwetsbaarheden in open-source libraries te identificeren, secret scanning om exposed credentials te detecteren, container scanning om kwetsbaarheden in container images te vinden, en security unit tests om beveiligingslogica te valideren.

Statische code-analyse (SAST) scant broncode op bekende kwetsbaarheden, security anti-patterns en afwijkingen van secure coding-standaarden. Tools zoals SonarQube, Veracode, Checkmarx of Microsoft Security Code Analysis kunnen worden geïntegreerd in Azure DevOps pipelines om automatisch code te analyseren bij elke build. SAST-resultaten worden geclassificeerd op basis van severity (kritiek, hoog, medium, laag) en worden gekoppeld aan specifieke code-regels. Pipeline gates kunnen worden geconfigureerd om builds te blokkeren wanneer kritieke of hoge kwetsbaarheden worden gedetecteerd, terwijl medium en lage bevindingen kunnen worden toegestaan maar wel moeten worden gedocumenteerd en opgevolgd. Door SAST structureel toe te passen, kunnen kwetsbaarheden vroegtijdig worden gedetecteerd en opgelost voordat code in productie terechtkomt.

Dependency scanning controleert alle open-source dependencies op bekende kwetsbaarheden (CVEs) en compliance-issues. Tools zoals WhiteSource, Snyk of GitHub Dependabot kunnen worden geïntegreerd in Azure DevOps pipelines om automatisch dependencies te scannen bij elke build. Wanneer een kwetsbare dependency wordt gedetecteerd, worden ontwikkelteams geïnformeerd over de kwetsbaarheid, de impact en beschikbare patches of alternatieven. Pipeline gates kunnen worden geconfigureerd om builds te blokkeren wanneer kritieke kwetsbaarheden worden gedetecteerd, of om waarschuwingen te genereren voor minder kritieke issues. Door dependency scanning structureel toe te passen, kunnen organisaties proactief kwetsbaarheden in dependencies adresseren en voorkomen dat bekende kwetsbaarheden in productie terechtkomen.

Secret scanning detecteert exposed credentials, API keys, tokens en andere gevoelige informatie in code, configuratiebestanden en commit-geschiedenis. Tools zoals GitGuardian, TruffleHog of GitHub Advanced Security kunnen worden geïntegreerd in Azure DevOps pipelines om automatisch te scannen op secret patterns. Wanneer een secret wordt gedetecteerd, worden ontwikkelteams onmiddellijk geïnformeerd en kunnen automatische maatregelen worden genomen zoals het automatisch revoken van exposed secrets en het forceren van secret rotation. Pipeline gates moeten worden geconfigureerd om builds te blokkeren wanneer secrets worden gedetecteerd, omdat exposed secrets een directe security risk vormen. Door secret scanning structureel toe te passen, kunnen organisaties voorkomen dat credentials worden blootgesteld in repositories en kunnen zij snel reageren wanneer dit toch gebeurt.

Container scanning controleert container images op kwetsbaarheden, misconfiguraties en compliance-issues. Tools zoals Trivy, Aqua Security of Microsoft Defender voor Containers kunnen worden geïntegreerd in Azure DevOps pipelines om automatisch container images te scannen na build. Wanneer kwetsbaarheden worden gedetecteerd, worden ontwikkelteams geïnformeerd en kunnen pipeline gates worden geconfigureerd om deployments te blokkeren wanneer kritieke kwetsbaarheden aanwezig zijn. Door container scanning structureel toe te passen, kunnen organisaties ervoor zorgen dat alleen veilige container images worden uitgerold naar productie.

Security Testing in de SDLC

Security testing omvat alle activiteiten die worden uitgevoerd om te verifiëren dat applicaties en services voldoen aan beveiligingsvereisten en resistent zijn tegen aanvallen. Security testing wordt uitgevoerd in meerdere fasen van de SDLC, waarbij verschillende testtechnieken worden gebruikt afhankelijk van de fase en het risiconiveau. In de ontwikkelfase worden security unit tests uitgevoerd om beveiligingslogica te valideren, en worden SAST en dependency scanning uitgevoerd om kwetsbaarheden in code te detecteren. In de testfase worden dynamic application security testing (DAST), interactive application security testing (IAST) en penetration testing uitgevoerd om runtime-kwetsbaarheden te identificeren. In de productiefase worden continue security monitoring en threat detection uitgevoerd om nieuwe bedreigingen te identificeren.

Dynamic Application Security Testing (DAST) test applicaties tijdens runtime om kwetsbaarheden te identificeren die alleen zichtbaar zijn wanneer de applicatie draait. DAST-tools zoals OWASP ZAP, Burp Suite of Microsoft Defender voor Cloud Apps simuleren aanvallen op applicaties en analyseren responses om kwetsbaarheden te detecteren. DAST wordt typisch uitgevoerd in staging-omgevingen voordat code naar productie wordt uitgerold, en kan worden geautomatiseerd in CI/CD pipelines. DAST-resultaten worden geclassificeerd op basis van severity en worden gekoppeld aan specifieke endpoints en parameters. Pipeline gates kunnen worden geconfigureerd om deployments te blokkeren wanneer kritieke kwetsbaarheden worden gedetecteerd. Door DAST structureel toe te passen, kunnen runtime-kwetsbaarheden worden geïdentificeerd die niet zichtbaar zijn in statische code-analyse.

Penetration testing is een diepgaande security assessment waarbij security experts proberen om applicaties en systemen te compromitteren door middel van gecontroleerde aanvallen. Penetration testing wordt typisch uitgevoerd door externe security consultants of interne red teams, en omvat zowel geautomatiseerde als handmatige testtechnieken. Voor kritieke applicaties of services moet penetration testing periodiek worden uitgevoerd, bijvoorbeeld jaarlijks of na significante wijzigingen. Penetration test-resultaten worden vastgelegd in gedetailleerde rapporten die kwetsbaarheden beschrijven, de impact analyseren en remediatie-aanbevelingen bevatten. Bevindingen uit penetration tests worden opgenomen in de security backlog en worden geprioriteerd op basis van severity en business impact. Door penetration testing structureel toe te passen, kunnen organisaties diepgaande security assessments uitvoeren die verder gaan dan geautomatiseerde tools.

Security unit tests valideren beveiligingslogica in code, zoals authenticatie, autorisatie, input validation en encryption. Security unit tests worden geschreven door ontwikkelaars en worden uitgevoerd als onderdeel van de normale unit test suite. Door security unit tests structureel toe te passen, kunnen ontwikkelteams verifiëren dat beveiligingslogica correct werkt en kunnen regressies worden gedetecteerd wanneer code wordt gewijzigd.

Monitoring en Compliance

Gebruik PowerShell-script secure-development-lifecycle.ps1 (functie Invoke-Monitoring) – Controleert Azure DevOps-projecten op aanwezigheid van security gates, threat modeling documentatie en security training compliance..

Continue monitoring is essentieel om te borgen dat de SDLC effectief blijft en om security-incidenten snel te detecteren. Monitoring dekt meerdere aspecten: pipeline-executie wordt gemonitord om te verifiëren dat security gates worden uitgevoerd en dat builds falen wanneer gates niet worden gepasseerd, code quality metrics worden gemonitord om trends te identificeren in security-bevindingen en om verbeteringen te meten, en security-incidenten worden gemonitord om patronen te identificeren en om lessons learned te integreren in de SDLC. Azure DevOps biedt ingebouwde reporting en analytics die kunnen worden gebruikt om SDLC-compliance te monitoren, inclusief pipeline-success rates, security gate-pass rates en code quality trends.

Compliance-rapportage maakt het mogelijk om aan auditors en toezichthouders aan te tonen dat de SDLC effectief is ingericht en wordt onderhouden. Rapportages bevatten overzichten van security gates in pipelines, threat modeling documentatie, security test-resultaten, code quality metrics en security training compliance. Deze rapportages worden periodiek gegenereerd, bijvoorbeeld maandelijks of per kwartaal, en worden besproken in governance-overleggen met bestuur, CISO en compliance officers. Door compliance-rapportage te automatiseren waar mogelijk, wordt de administratieve last verminderd en wordt consistentie gewaarborgd tussen verschillende rapportages.

Audit trails zijn essentieel voor compliance en forensisch onderzoek. Alle belangrijke activiteiten in de SDLC moeten worden gelogd, inclusief code commits, pipeline-executies, security gate-resultaten, code reviews, threat modeling-sessies en security test-resultaten. Logs moeten worden opgeslagen in een centraal, beveiligd systeem zoals Azure Log Analytics, met retention policies die voldoen aan wettelijke vereisten (bijvoorbeeld 7 jaar volgens de Archiefwet). Logs moeten worden beschermd tegen manipulatie, bijvoorbeeld door write-once storage of digitale handtekeningen, zodat zij betrouwbaar zijn voor auditdoeleinden. Door audit trails te integreren in de SDLC en regelmatig te verifiëren dat alle vereiste events worden gelogd, kunnen organisaties aantonen dat zij voldoen aan compliance-vereisten en kunnen zij snel reageren op security-incidenten.

Remediatie en Verbetering

Gebruik PowerShell-script secure-development-lifecycle.ps1 (functie Invoke-Remediation) – Genereert een overzicht van ontbrekende SDLC-componenten en verbeteracties..

Wanneer uit monitoring, audits of security-assessments blijkt dat de SDLC onvoldoende is ingericht, moet direct actie worden ondernomen. De eerste stap is een gap analysis: welke SDLC-componenten ontbreken, welke zijn verouderd, en welke zijn niet effectief? Deze analyse wordt uitgevoerd door security-teams in samenwerking met ontwikkelteams en product owners, zodat alle perspectieven worden meegenomen. Op basis van de gap analysis wordt een remediatieplan opgesteld met concrete acties, verantwoordelijken en termijnen. High-risk findings krijgen prioriteit, zodat de meest kritieke beveiligingshiaten eerst worden opgelost.

Remediatie-acties kunnen variëren van technische implementaties zoals het toevoegen van security gates aan pipelines, het implementeren van threat modeling-processen, of het opzetten van security testing, tot organisatorische maatregelen zoals het opstellen van secure coding-standaarden, het trainen van ontwikkelaars, of het inrichten van security review-processen. Het is belangrijk om remediatie te plannen in een roadmap met duidelijke mijlpalen, zodat voortgang kan worden gemonitord en bestuur kan worden geïnformeerd over de status van security-verbeteringen. Door remediatie te koppelen aan bestaande verbeterprogramma's voor informatiebeveiliging en compliance, wordt voorkomen dat de SDLC een losstaand thema blijft en wordt gewaarborgd dat verbeteringen duurzaam zijn.

Continue verbetering is essentieel omdat beveiliging een snel evoluerend domein is: nieuwe bedreigingen worden ontdekt, nieuwe beveiligingstechnieken worden ontwikkeld, en wet- en regelgeving wordt regelmatig bijgewerkt. De SDLC moet daarom periodiek worden herzien en bijgewerkt, bijvoorbeeld jaarlijks of wanneer significante wijzigingen plaatsvinden in de ontwikkelomgeving of in relevante kaders. Lessons learned uit security-incidenten, audits en assessments moeten worden geïntegreerd in de SDLC, zodat organisaties kunnen leren van ervaringen en hun beveiligingsposture continu kunnen verbeteren. Door de SDLC te zien als een doorlopend proces in plaats van een eenmalige implementatie, kunnen organisaties proactief blijven reageren op nieuwe bedreigingen en compliance-vereisten.

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 Secure Development Lifecycle (SDLC) monitoring, compliance checks en security gates voor Azure DevOps. .DESCRIPTION Ondersteunt het artikel "Secure Development Lifecycle voor Azure DevOps en CI/CD-pipelines" binnen het programma Nederlandse Baseline voor Veilige Cloud. Het script voert security scans uit, valideert security gates, controleert SDLC compliance en genereert rapporten. Alle functies ondersteunen DebugMode zodat lokale tests zonder cloudverbinding kunnen worden uitgevoerd. .NOTES Filename: secure-development-lifecycle.ps1 Author: Nederlandse Baseline voor Veilige Cloud Created: 2025-11-27 Last Modified: 2025-11-27 Version: 1.0 Related JSON: content/azure/devops/secure-development-lifecycle.json Category: devops Workload: azure .LINK https://github.com/m365-tenant-best-practise .EXAMPLE .\secure-development-lifecycle.ps1 -DebugMode Voert SDLC compliance checks uit met voorbeelddata en slaat output op in de huidige map. .EXAMPLE .\secure-development-lifecycle.ps1 -Function Invoke-SDLCCodeSecurityScan -DebugMode Voert automatische security scans uit op code repositories met voorbeelddata. .EXAMPLE .\secure-development-lifecycle.ps1 -Function Invoke-SDLCSecurityGates -DebugMode Configureert en valideert security gates in CI/CD pipelines. #> #Requires -Version 5.1 #Requires -Modules Az.Accounts [CmdletBinding()] param( [Parameter(HelpMessage = "Voer het script uit met voorbeelddata en zonder cloudverbinding.")] [switch]$DebugMode, [Parameter(HelpMessage = "Bepaal welke functie moet draaien.")] [ValidateSet("Invoke-SDLCCodeSecurityScan", "Invoke-SDLCSecurityGates", "Invoke-SDLCInfrastructureSecurityScan", "Invoke-SDLCComplianceReporting")] [string]$Function = "Invoke-SDLCCodeSecurityScan", [Parameter(HelpMessage = "Kies de exportmap voor resultaten.")] [ValidateNotNullOrEmpty()] [string]$ExportRoot = ".", [Parameter(HelpMessage = "Schakel forensische modus in waardoor exports read-only worden.")] [switch]$FailSafe ) $ErrorActionPreference = 'Stop' Write-Host "`n==================================================" -ForegroundColor Cyan Write-Host "Secure Development Lifecycle (SDLC)" -ForegroundColor Cyan Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan Write-Host "==================================================`n" -ForegroundColor Cyan function Connect-SDLCContext { <# .SYNOPSIS Maakt verbinding met Azure en Azure DevOps indien nodig. #> [CmdletBinding()] param() if ($DebugMode) { Write-Host "DebugMode actief: overslaan van cloudverbindingen." -ForegroundColor Yellow return } Write-Host "Verbinding maken met Azure..." -ForegroundColor Gray Connect-AzAccount -ErrorAction Stop | Out-Null Write-Host "Azure sessie actief." -ForegroundColor Green } function Get-SDLCSourceData { <# .SYNOPSIS Haalt SDLC security data op of levert voorbeelddata. .OUTPUTS Hashtable #> [CmdletBinding()] param() if ($DebugMode) { return @{ GeneratedAt = Get-Date Repositories = @( @{ Name = "fraud-detection-api" SASTIssues = 3 DependencyVulnerabilities = 2 CodeReviewCoverage = 0.95 }, @{ Name = "risk-analysis-service" SASTIssues = 1 DependencyVulnerabilities = 0 CodeReviewCoverage = 1.0 } ) Pipelines = @( @{ Name = "fraud-detection-pipeline" SecurityGatesEnabled = $true SASTGatePassed = $true DependencyScanGatePassed = $true }, @{ Name = "risk-analysis-pipeline" SecurityGatesEnabled = $false SASTGatePassed = $null DependencyScanGatePassed = $null } ) InfrastructureTemplates = @( @{ Name = "main.bicep" Misconfigurations = 2 }, @{ Name = "terraform/main.tf" Misconfigurations = 0 } ) ComplianceStatus = @{ "BIO" = @{Compliant = $true; Score = 92} "NIS2" = @{Compliant = $false; Score = 78; MissingControls = @("Threat modeling", "Penetration testing")} } } } Write-Verbose "Productiedata ophalen..." return @{ GeneratedAt = Get-Date Repositories = @() Pipelines = @() InfrastructureTemplates = @() ComplianceStatus = @{} } } function Invoke-SDLCCodeSecurityScan { <# .SYNOPSIS Voert automatische security scans uit op code repositories. .OUTPUTS PSCustomObject #> [CmdletBinding()] param() Connect-SDLCContext Write-Host "Code security scan uitvoeren..." -ForegroundColor Gray $source = Get-SDLCSourceData $totalSASTIssues = ($source.Repositories | Measure-Object -Property SASTIssues -Sum).Sum $totalDependencyVulns = ($source.Repositories | Measure-Object -Property DependencyVulnerabilities -Sum).Sum $avgCodeReviewCoverage = ($source.Repositories | Measure-Object -Property CodeReviewCoverage -Average).Average $scan = [PSCustomObject]@{ Function = "Invoke-SDLCCodeSecurityScan" GeneratedAt = $source.GeneratedAt TotalRepositories = $source.Repositories.Count TotalSASTIssues = $totalSASTIssues TotalDependencyVulns = $totalDependencyVulns AvgCodeReviewCoverage = [Math]::Round($avgCodeReviewCoverage * 100, 2) SecurityScore = [Math]::Max(0, 100 - ($totalSASTIssues * 5) - ($totalDependencyVulns * 10)) DebugMode = [bool]$DebugMode } $timestamp = Get-Date -Format "yyyyMMdd-HHmmss" $exportDir = Join-Path (Resolve-Path $ExportRoot) "sdlc-code-security-$timestamp" New-Item -Path $exportDir -ItemType Directory -Force | Out-Null $jsonPath = Join-Path $exportDir "code-security-scan.json" $scan | ConvertTo-Json -Depth 6 | Out-File -FilePath $jsonPath -Encoding UTF8 Write-Host "`nCode Security Scan Resultaten:" -ForegroundColor Cyan Write-Host " Repositories gescand: $($scan.TotalRepositories)" -ForegroundColor Gray Write-Host " SAST Issues: $($scan.TotalSASTIssues)" -ForegroundColor $(if ($scan.TotalSASTIssues -eq 0) { "Green" } else { "Yellow" }) Write-Host " Dependency Vulnerabilities: $($scan.TotalDependencyVulns)" -ForegroundColor $(if ($scan.TotalDependencyVulns -eq 0) { "Green" } else { "Yellow" }) Write-Host " Code Review Coverage: $($scan.AvgCodeReviewCoverage)%" -ForegroundColor Gray Write-Host " Security Score: $($scan.SecurityScore)%" -ForegroundColor $(if ($scan.SecurityScore -ge 80) { "Green" } else { "Yellow" }) Write-Host "`nResultaten opgeslagen in: $jsonPath" -ForegroundColor Green return [PSCustomObject]@{ Function = "Invoke-SDLCCodeSecurityScan" ExportDir = $exportDir DataFile = $jsonPath Scan = $scan Summary = "Code security scan voltooid voor $($scan.TotalRepositories) repositories." } } function Invoke-SDLCSecurityGates { <# .SYNOPSIS Configureert en valideert security gates in CI/CD pipelines. .OUTPUTS PSCustomObject #> [CmdletBinding()] param() Connect-SDLCContext Write-Host "Security gates valideren..." -ForegroundColor Gray $source = Get-SDLCSourceData $gatesEnabled = ($source.Pipelines | Where-Object { $_.SecurityGatesEnabled -eq $true }).Count $gatesMissing = ($source.Pipelines | Where-Object { $_.SecurityGatesEnabled -eq $false }).Count $gateStatus = [PSCustomObject]@{ Function = "Invoke-SDLCSecurityGates" GeneratedAt = $source.GeneratedAt TotalPipelines = $source.Pipelines.Count GatesEnabled = $gatesEnabled GatesMissing = $gatesMissing ComplianceRate = if ($source.Pipelines.Count -gt 0) { [Math]::Round(($gatesEnabled / $source.Pipelines.Count) * 100, 2) } else { 0 } DebugMode = [bool]$DebugMode } $timestamp = Get-Date -Format "yyyyMMdd-HHmmss" $exportDir = Join-Path (Resolve-Path $ExportRoot) "sdlc-security-gates-$timestamp" New-Item -Path $exportDir -ItemType Directory -Force | Out-Null $jsonPath = Join-Path $exportDir "security-gates.json" $gateStatus | ConvertTo-Json -Depth 6 | Out-File -FilePath $jsonPath -Encoding UTF8 Write-Host "`nSecurity Gates Status:" -ForegroundColor Cyan Write-Host " Pipelines gecontroleerd: $($gateStatus.TotalPipelines)" -ForegroundColor Gray Write-Host " Gates ingeschakeld: $($gateStatus.GatesEnabled)" -ForegroundColor Green Write-Host " Gates ontbrekend: $($gateStatus.GatesMissing)" -ForegroundColor $(if ($gateStatus.GatesMissing -eq 0) { "Green" } else { "Yellow" }) Write-Host " Compliance Rate: $($gateStatus.ComplianceRate)%" -ForegroundColor $(if ($gateStatus.ComplianceRate -ge 90) { "Green" } else { "Yellow" }) Write-Host "`nResultaten opgeslagen in: $jsonPath" -ForegroundColor Green return [PSCustomObject]@{ Function = "Invoke-SDLCSecurityGates" ExportDir = $exportDir DataFile = $jsonPath GateStatus = $gateStatus Summary = "Security gates gecontroleerd voor $($gateStatus.TotalPipelines) pipelines." } } function Invoke-SDLCInfrastructureSecurityScan { <# .SYNOPSIS Scant Infrastructure as Code templates op security misconfigurations. .OUTPUTS PSCustomObject #> [CmdletBinding()] param() Connect-SDLCContext Write-Host "Infrastructure security scan uitvoeren..." -ForegroundColor Gray $source = Get-SDLCSourceData $totalMisconfigurations = ($source.InfrastructureTemplates | Measure-Object -Property Misconfigurations -Sum).Sum $infraScan = [PSCustomObject]@{ Function = "Invoke-SDLCInfrastructureSecurityScan" GeneratedAt = $source.GeneratedAt TotalTemplates = $source.InfrastructureTemplates.Count TotalMisconfigurations = $totalMisconfigurations SecurityScore = if ($source.InfrastructureTemplates.Count -gt 0) { [Math]::Max(0, 100 - ($totalMisconfigurations * 15)) } else { 100 } DebugMode = [bool]$DebugMode } $timestamp = Get-Date -Format "yyyyMMdd-HHmmss" $exportDir = Join-Path (Resolve-Path $ExportRoot) "sdlc-infrastructure-$timestamp" New-Item -Path $exportDir -ItemType Directory -Force | Out-Null $jsonPath = Join-Path $exportDir "infrastructure-security-scan.json" $infraScan | ConvertTo-Json -Depth 6 | Out-File -FilePath $jsonPath -Encoding UTF8 Write-Host "`nInfrastructure Security Scan Resultaten:" -ForegroundColor Cyan Write-Host " Templates gescand: $($infraScan.TotalTemplates)" -ForegroundColor Gray Write-Host " Misconfigurations: $($infraScan.TotalMisconfigurations)" -ForegroundColor $(if ($infraScan.TotalMisconfigurations -eq 0) { "Green" } else { "Yellow" }) Write-Host " Security Score: $($infraScan.SecurityScore)%" -ForegroundColor $(if ($infraScan.SecurityScore -ge 80) { "Green" } else { "Yellow" }) Write-Host "`nResultaten opgeslagen in: $jsonPath" -ForegroundColor Green return [PSCustomObject]@{ Function = "Invoke-SDLCInfrastructureSecurityScan" ExportDir = $exportDir DataFile = $jsonPath Scan = $infraScan Summary = "Infrastructure security scan voltooid voor $($infraScan.TotalTemplates) templates." } } function Invoke-SDLCComplianceReporting { <# .SYNOPSIS Genereert compliance rapporten voor SDLC processen. .OUTPUTS PSCustomObject #> [CmdletBinding()] param() Connect-SDLCContext Write-Host "Compliance rapportage genereren..." -ForegroundColor Gray $source = Get-SDLCSourceData $compliance = [PSCustomObject]@{ Function = "Invoke-SDLCComplianceReporting" GeneratedAt = $source.GeneratedAt ComplianceStatus = $source.ComplianceStatus OverallCompliant = ($source.ComplianceStatus.Values | Where-Object { $_.Compliant -eq $false }).Count -eq 0 DebugMode = [bool]$DebugMode } $timestamp = Get-Date -Format "yyyyMMdd-HHmmss" $exportDir = Join-Path (Resolve-Path $ExportRoot) "sdlc-compliance-$timestamp" New-Item -Path $exportDir -ItemType Directory -Force | Out-Null $jsonPath = Join-Path $exportDir "sdlc-compliance-report.json" $compliance | ConvertTo-Json -Depth 6 | Out-File -FilePath $jsonPath -Encoding UTF8 Write-Host "`nSDLC Compliance Rapport:" -ForegroundColor Cyan foreach ($framework in $source.ComplianceStatus.Keys) { $status = $source.ComplianceStatus[$framework] $color = if ($status.Compliant) { "Green" } else { "Yellow" } Write-Host " $framework : $(if ($status.Compliant) { 'Compliant' } else { 'Non-Compliant' }) (Score: $($status.Score)%)" -ForegroundColor $color if (-not $status.Compliant -and $status.MissingControls) { foreach ($control in $status.MissingControls) { Write-Host " - Missing: $control" -ForegroundColor Yellow } } } Write-Host "`nResultaten opgeslagen in: $jsonPath" -ForegroundColor Green return [PSCustomObject]@{ Function = "Invoke-SDLCComplianceReporting" ExportDir = $exportDir DataFile = $jsonPath Compliance = $compliance Summary = "Compliance rapportage gegenereerd. Overall compliant: $($compliance.OverallCompliant)." } } # Main execution try { switch ($Function) { "Invoke-SDLCCodeSecurityScan" { $result = Invoke-SDLCCodeSecurityScan } "Invoke-SDLCSecurityGates" { $result = Invoke-SDLCSecurityGates } "Invoke-SDLCInfrastructureSecurityScan" { $result = Invoke-SDLCInfrastructureSecurityScan } "Invoke-SDLCComplianceReporting" { $result = Invoke-SDLCComplianceReporting } default { Write-Error "Onbekende functie: $Function" exit 1 } } Write-Host "`n$($result.Summary)" -ForegroundColor Green Write-Host "`nKlaar!" -ForegroundColor Green } catch { Write-Host "`nFout opgetreden: $_" -ForegroundColor Red Write-Host $_.ScriptStackTrace -ForegroundColor Gray exit 1 }

Risico zonder implementatie

Risico zonder implementatie
High: Zonder een gestructureerde Secure Development Lifecycle blijven applicaties kwetsbaar voor bekende aanvallen, wat kan leiden tot security breaches, data exfiltration, service disruptions en niet-naleving van regelgeving zoals BIO, NIS2 en ISO 27001.

Management Samenvatting

Implementeer een complete Secure Development Lifecycle met security gates in CI/CD pipelines, threat modeling, secure coding-standaarden, security testing en continue monitoring. Gebruik het script secure-development-lifecycle.ps1 voor geautomatiseerde SDLC-compliance checks en verbeteracties.