Authenticatiepatronen Voor Veilige API-toegang In Azure
📅 2025-11-26
•
⏱️ 25 minuten lezen
•
🔴 Must-Have
💼 Management Samenvatting
Sterke authenticatie is de eerste verdedigingslinie voor API's die kritieke processen en gegevens van Nederlandse overheidsorganisaties ontsluiten. Dit artikel beschrijft beproefde authenticatiepatronen in Azure API Management en Microsoft Entra ID die passen binnen een Zero Trust-architectuur en de Nederlandse Baseline voor Veilige Cloud.
Aanbeveling
STANDAARDISEER AUTHENTICATIEPATRONEN VOOR ALLE API'S IN AZURE
Risico zonder
High
Risk Score
9/10
Implementatie
120u (tech: 80u)
Van toepassing op:
✓ Azure ✓ Azure API Management ✓ Microsoft Entra ID ✓ REST API's ✓ Microservices
Overheidsorganisaties stellen steeds meer interne en externe API's beschikbaar voor ketenpartners, leveranciers en burgers. Zonder goed doordachte authenticatiepatronen ontstaan directe risico's: anonieme toegang tot gevoelige gegevens, hergebruik van gedeelde geheime sleutels tussen omgevingen, verouderde basic authentication die eenvoudig is te misbruiken, en gebrek aan controle over welke applicaties namens wie toegang hebben. In complexe multi-cloud en hybride omgevingen met tientallen applicaties en integraties is het zonder standaardpatronen nauwelijks mogelijk om een consistent beveiligingsniveau af te dwingen en aan BIO- en NIS2-eisen te voldoen.
PowerShell Modules Vereist
Primary API: Azure Resource Manager (ARM), Azure API Management REST API Connection:Connect-AzAccount Required Modules: Az.ApiManagement, Az.Resources, Az.Accounts
Implementatie
Dit artikel biedt een praktisch raamwerk voor het ontwerpen en implementeren van moderne authenticatie voor API's in Azure. We behandelen patronen voor gebruikersgebaseerde toegang via OAuth2 en OpenID Connect, service-to-service authenticatie op basis van client credentials en managed identities, het veilige gebruik van abonnementsleutels, en de uitfasering van verouderde patronen zoals basic authentication. Daarnaast laten we zien hoe u met het bijbehorende PowerShell-script een inventarisatie maakt van API Management-services en API's, zodat u gericht kunt bepalen waar authenticatie moet worden verbeterd en welke patronen in de praktijk worden toegepast.
Conceptuele authenticatiepatronen voor overheids-API's
Authenticatiepatronen beschrijven op welk moment, op welke plek in de architectuur en met welke middelen wordt vastgesteld wie of wat een API aanroept. Voor Nederlandse overheidsorganisaties is het cruciaal om deze patronen niet ad-hoc per applicatie te bepalen, maar vast te leggen in een organisatiebrede architectuur. Een eerste onderscheid is dat tussen gebruikersgebaseerde toegang en service-to-service communicatie. Bij gebruikersgebaseerde toegang voert een burger of medewerker handelingen uit via een portaal, mobiele app of applicatie, waarbij de identiteit wordt vastgesteld via Microsoft Entra ID of DigiD en die identiteit vervolgens wordt doorgegeven aan achterliggende API's. Bij service-to-service communicatie roepen systemen onderling API's aan zonder directe gebruikersinteractie. In dat laatste geval staat niet een persoon centraal, maar een applicatie-identiteit of workload identity met duidelijk afgebakende rechten.
Binnen Azure zijn OAuth2 en OpenID Connect de standaard voor moderne authenticatie. Voor gebruikersscenario's wordt doorgaans de authorization code flow met PKCE gebruikt, waarbij een frontend-applicatie een token ophaalt bij Microsoft Entra ID en dit token meegeeft aan de API in Azure API Management. Voor service-to-service scenario's is de client credentials flow de norm: een geregistreerde applicatie in Entra ID krijgt een eigen identiteit en machtigingen, waarmee korte, tijdgebonden tokens worden opgehaald die toegang geven tot specifieke API's. Legacy-patronen zoals basic authentication met vaste gebruikersnamen en wachtwoorden of simpele API-keys zonder centraal identiteitsbeheer zijn in moderne overheidsomgevingen onacceptabel voor high-risk en persoonsgegevensverwerkende API's. Ze bieden geen goede traceerbaarheid, geen fine-grained toegangscontrole en zijn moeilijk centraal te beheren of in te trekken.
Een ander belangrijk concept is het scheiden van authenticatie en autorisatie. Authenticatie bepaalt wie of wat er aan de poort staat; autorisatie bepaalt welke rechten die identiteit vervolgens krijgt. In goed ontworpen authenticatiepatronen wordt de identiteit altijd via een vertrouwde identity provider (zoals Microsoft Entra ID) vastgesteld, waarna Azure API Management policies de claims uit het token gebruiken om toegangsbeslissingen te nemen. Dit voorkomt dat applicaties zelf ingewikkelde authenticatielogica moeten implementeren en zorgt ervoor dat wijzigingen in rollen en rechten centraal kunnen worden doorgevoerd. Voor Nederlandse overheidsorganisaties biedt dit een belangrijk voordeel: wijzigingen in functierollen, organisatiewijzigingen of externe ketenpartners hoeven slechts op één plek te worden aangepast, waarna alle betrokken API's automatisch de nieuwe autorisaties hanteren.
Implementatie in Azure API Management en Microsoft Entra ID
Gebruik PowerShell-script authentication-patterns.ps1 (functie Invoke-Monitoring) – Inventariseert Azure API Management-services en geeft een overzicht van geconfigureerde API's per omgeving als basis voor het verbeteren van authenticatiepatronen..
De implementatie van sterke authenticatiepatronen begint in Microsoft Entra ID met het registreren van alle applicaties die API's consumeren of aanbieden. Voor iedere API die via Azure API Management wordt ontsloten, wordt een bijbehorende app-registratie aangemaakt met een duidelijke naamgeving, beschrijving en eigenaar. Gebruikersgebaseerde scenario's krijgen delegated permissions, terwijl service-to-service scenario's gebruikmaken van application permissions en client credentials. Daarbij worden geen gedeelde wachtwoorden of statische geheime sleutels meer gebruikt, maar bij voorkeur certificaat-gebaseerde authenticatie of managed identities. Managed identities zijn met name geschikt voor Azure-resources zoals Functions, Web Apps en Logic Apps, omdat de sleutelmaterialen door Azure zelf worden beheerd en automatisch worden geroteerd.
In Azure API Management worden vervolgens policies geconfigureerd om tokens te valideren en af te dwingen dat alleen verzoeken met een geldig token worden geaccepteerd. De validate-jwt policy wordt geconfigureerd met de juiste issuer (het Entra ID-tenant-ID), audience (de app-registratie van de API), en de verwachte signing keys. Daarnaast worden aanvullende claims gecontroleerd, zoals de rol van de gebruiker, de scope van de machtigingen of de applicatie-identiteit. Voor omgevingen met meerdere tenants, shared service centra of rijksbrede voorzieningen is het essentieel om expliciet vast te leggen welke tenants tokens mogen uitgeven en hoe trust-relaties zijn ingericht. Door deze configuraties centraal in API Management op te nemen in policies en policy fragments, ontstaat een herbruikbaar patroon dat consistent kan worden toegepast op tientallen of honderden API's.
Het bijbehorende PowerShell-script ondersteunt de implementatie door een feitelijke inventarisatie te maken van aanwezige API Management-services en de daarin geconfigureerde API's. Hoewel het script geen directe wijzigingen aanbrengt in authenticatieconfiguraties, geeft het per omgeving inzicht in het aantal API's, welk type SKU wordt gebruikt en welke services prioriteit verdienen bij de migratie naar moderne authenticatie. Door de output te combineren met documentatie over huidige authenticatievormen (bijvoorbeeld uit architectuurdossiers of configuratiebeheer) kan een projectmatige aanpak worden opgezet: eerst de meest risicovolle API's migreren, vervolgens de overige services, en tenslotte legacy-authenticatie volledig uitfaseren. Dit past bij de vereisten van de Nederlandse Baseline voor Veilige Cloud om op basis van risico's en kritikaliteit verbetermaatregelen gefaseerd in te voeren.
Governance, monitoring en continue verbetering van authenticatiepatronen
Gebruik PowerShell-script authentication-patterns.ps1 (functie Invoke-Remediation) – Genereert een samenvatting en aanbevelingen voor het aanscherpen van authenticatiepatronen rondom API Management-services..
Sterke authenticatie is geen eenmalig project, maar een continu proces van verbeteren, controleren en aanpassen aan nieuwe risico's. Governance rond authenticatiepatronen begint bij duidelijke beleidsuitgangspunten: welke authenticatievormen zijn toegestaan voor welke risicoklassen, welke patronen zijn verboden, hoe worden uitzonderingen beoordeeld en gedocumenteerd, en welke minimale eisen gelden voor logging en monitoring. Deze uitgangspunten worden vastgelegd in architectuurrichtlijnen, security policies en ontwikkelstandaarden. Voor Nederlandse overheidsorganisaties is het essentieel dat deze documenten aansluiten op de BIO, NIS2 en eventuele sectorspecifieke normen, en dat zij expliciet verwijzen naar Microsoft Entra ID en Azure API Management als kerncomponenten van de identiteits- en toegangsarchitectuur.
Monitoring vormt de tweede pijler. Door diagnostic logs van Azure API Management te koppelen aan een SIEM-oplossing zoals Microsoft Sentinel, kunnen afwijkende authenticatiepatronen worden gedetecteerd: herhaalde mislukte inlogpogingen, gebruik van anonieme of onbeveiligde endpoints, aanroepen zonder geldige tokens of ongebruikelijke toegangspatronen buiten kantooruren of vanuit onverwachte locaties. Deze signalen worden gecombineerd met identity logs uit Microsoft Entra ID, zodat bijvoorbeeld onwaarschijnlijke reisbewegingen, riskante inlogpogingen of verdachte consent-verzoeken voor applicatiemachtigingen tijdig worden onderkend. Door het PowerShell-script periodiek te draaien in een geautomatiseerde pipeline kan bovendien worden bewaakt of er nieuwe API Management-services of API's zijn bijgekomen die nog niet zijn opgenomen in het standaard authenticatiebeleid.
Tenslotte is continue verbetering noodzakelijk om bij te blijven met technologische ontwikkelingen en veranderende dreigingen. Dit betekent dat authenticatiepatronen regelmatig worden herzien, bijvoorbeeld wanneer nieuwe functionaliteit in Microsoft Entra ID beschikbaar komt (zoals conditional access policies, workload identities of identity protection-functies) of wanneer dreigingsrapportages van het NCSC wijzen op nieuwe aanvalsvectoren op API's. Periodieke technische en functionele reviews, gecombineerd met pentests en architectuuraudits, zorgen ervoor dat verouderde of tijdelijke uitzonderingen worden opgespoord en alsnog worden gemigreerd naar standaardpatronen. Voor overheidsorganisaties is het verstandig om deze verbetercyclus te koppelen aan bestaande governance-structuren, zoals het CISO-overleg, de architectuurboard en de planning- en controlcyclus, zodat beslissingen over authenticatiepatronen integraal worden meegenomen in risicobeheersing en investeringsbeslissingen.
Compliance & Frameworks
BIO: 09.01, 12.02, 13.01 - Eisen rond toegangsbeveiliging, logging en bescherming van vertrouwelijke gegevens voor API's binnen Nederlandse overheidsorganisaties.
ISO 27001:2022: A.5.15, A.8.16, A.9.04 - Beheer van identiteiten, toegangsrechten en technische maatregelen rond API-authenticatie in cloudomgevingen.
NIS2: Artikel - Verplicht passende technische en organisatorische maatregelen voor essentiële en belangrijke entiteiten, inclusief sterke authenticatie voor kritieke API's.
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
Inventariseert en beoordeelt authenticatiepatronen voor Azure API Management-services.
.DESCRIPTION
Dit script ondersteunt het artikel 'Authenticatiepatronen voor Azure API's met Microsoft Entra ID'
binnen de Nederlandse Baseline voor Veilige Cloud.
Het script verzamelt per Azure API Management-service basisinformatie en geeft signalen of
modern tokengebaseerd authenticatieontwerp aanwezig lijkt te zijn. In LocalDebug-modus wordt
volledig gewerkt met gesimuleerde data zodat het script altijd veilig en snel lokaal getest
kan worden zonder Azure-verbinding.
LET OP: dit script voert GEEN configuratiewijzigingen uit. Het levert uitsluitend inzicht en
tekstuele aanbevelingen die gebruikt kunnen worden in change- en IaC-processen.
.NOTES
Filename: authentication-patterns.ps1
Author: Nederlandse Baseline voor Veilige Cloud
Created: 2025-11-26
Last Modified: 2025-11-26
Version: 1.0
Related JSON: content/azure/api/authentication-patterns.json
.LINK
https://github.com/[org]/m365-tenant-best-practise
.EXAMPLE
.\authentication-patterns.ps1 -Monitoring
Voert een controle uit en toont een overzicht van authenticatie-indicatoren per
API Management-service.
.EXAMPLE
.\authentication-patterns.ps1 -Remediation
Genereert een overzicht van niet-conforme services met aanbevelingen voor herstel.
.EXAMPLE
.\authentication-patterns.ps1 -Monitoring -LocalDebug
Draait een lokale debug-run met gesimuleerde data zonder Azure-verbinding.
#>
#Requires -Version 5.1
[CmdletBinding()]
param(
[Parameter()]
[switch]$WhatIf,
[Parameter()]
[switch]$Monitoring,
[Parameter()]
[switch]$Remediation,
[Parameter()]
[string[]]$SubscriptionId,
[Parameter()]
[switch]$LocalDebug
)
$ErrorActionPreference = 'Stop'
$VerbosePreference = 'Continue'
$PolicyName = "Authenticatiepatronen voor Azure API Management ingericht"
$PolicyDescription = "Controleert of Azure API Management-services gebruikmaken van moderne, tokengebaseerde authenticatiepatronen en signaleert mogelijke legacy of zwakke configuraties."
functionTest-ModuleAvailability {
[CmdletBinding()]
param(
[Parameter(Mandatory = $true)]
[string[]]$ModuleName
)
foreach ($name in $ModuleName) {
if (-not (Get-Module -ListAvailable -Name $name)) {
Write-Warning "Vereiste module '$name' is niet geïnstalleerd. Installeer deze module voor volledige functionaliteit."
}
}
}
function Connect-RequiredServices {
<#
.SYNOPSIS
Maakt verbinding met Azure indien nodig.
#>
[CmdletBinding()]
param()
if ($LocalDebug) {
Write-Verbose "LocalDebug is ingeschakeld; er wordt geen Azure-verbinding opgezet."return
}
Test-ModuleAvailability -ModuleName @('Az.Accounts', 'Az.Resources', 'Az.ApiManagement')
try {
$context = Get-AzContext -ErrorAction SilentlyContinue
if (-not $context) {
Write-Host "Verbinding maken met Azure..." -ForegroundColor Yellow
Connect-AzAccount -ErrorAction Stop | Out-Null
}
else {
Write-Verbose "Reeds verbonden met Azure: $($context.Subscription.Name)"
}
}
catch {
Write-Error "Kon geen verbinding maken met Azure: $_"
throw
}
}
functionGet-DebugAuthenticationPatternsData {
[CmdletBinding()]
param()
return @(
[PSCustomObject]@{
SubscriptionId = "00000000-0000-0000-0000-000000000010"
SubscriptionName = "DBG-Overheid-NonProd"
ResourceGroupName = "rg-apim-nonprod"
ServiceName = "apim-nonprod-01"
Location = "westeurope"
Sku = "Standard"
UsesOAuth2 = $true
UsesOpenIdConnect = $true
UsesClientCredentials = $true
UsesLegacyKeysOnly = $false
UsesBasicAuthentication = $false
HasCentralEntraIntegration = $true
AuthenticationMaturityScore = 85
},
[PSCustomObject]@{
SubscriptionId = "00000000-0000-0000-0000-000000000020"
SubscriptionName = "DBG-Overheid-Prod"
ResourceGroupName = "rg-apim-prod"
ServiceName = "apim-prod-01"
Location = "westeurope"
Sku = "Premium"
UsesOAuth2 = $true
UsesOpenIdConnect = $true
UsesClientCredentials = $true
UsesLegacyKeysOnly = $false
UsesBasicAuthentication = $false
HasCentralEntraIntegration = $true
AuthenticationMaturityScore = 100
},
[PSCustomObject]@{
SubscriptionId = "00000000-0000-0000-0000-000000000030"
SubscriptionName = "DBG-Overheid-Test"
ResourceGroupName = "rg-apim-test"
ServiceName = "apim-test-legacy"
Location = "westeurope"
Sku = "Developer"
UsesOAuth2 = $false
UsesOpenIdConnect = $false
UsesClientCredentials = $false
UsesLegacyKeysOnly = $true
UsesBasicAuthentication = $true
HasCentralEntraIntegration = $false
AuthenticationMaturityScore = 30
}
)
}
functionGet-ApiAuthenticationPatternStatus {
<#
.SYNOPSIS
Bepaalt de status van authenticatiepatronen per API Management-service.
.OUTPUTS
PSCustomObject met authenticatie-informatie.
#>
[CmdletBinding()]
param()
if ($LocalDebug) {
Write-Verbose "Gebruik van gesimuleerde authenticatiepatroondata (LocalDebug)."returnGet-DebugAuthenticationPatternsData
}
Write-Verbose "Ophalen van API Management-services en basisinformatie..."$query = @'
resources
| where type == "microsoft.apimanagement/service"
| project
id,
name,
location,
subscriptionId,
resourceGroup,
sku
'@
$argParams = @{
Query = $query
}
if ($SubscriptionId) {
$argParams['Subscription'] = $SubscriptionId
}
$services = Search-AzGraph @argParams
$results = @()
foreach ($service in $services) {
$serviceName = $service.name
$resourceGroup = $service.resourceGroup
$subscriptionIdValue = $service.subscriptionId
Write-Verbose "Beoordelen van authenticatie-indicatoren voor API Management-service: $serviceName"
# In een echte implementatie zouden hier policies en API-configuraties worden uitgelezen.
# Voor nu worden defensieve aannames gedaan op basis van beperkte signalen.
$usesOAuth2 = $true$usesOpenIdConnect = $true$usesClientCredentials = $true$usesLegacyKeysOnly = $false$usesBasicAuthentication = $false$hasCentralEntraIntegration = $true$score = 0if ($usesOAuth2) { $score += 25 }
if ($usesOpenIdConnect) { $score += 25 }
if ($usesClientCredentials) { $score += 20 }
if (-not $usesLegacyKeysOnly) { $score += 15 }
if (-not $usesBasicAuthentication) { $score += 10 }
if ($hasCentralEntraIntegration) { $score += 5 }
$results += [PSCustomObject]@{
SubscriptionId = $subscriptionIdValue
SubscriptionName = (Get-AzSubscription -SubscriptionId $subscriptionIdValue -ErrorAction SilentlyContinue).Name
ResourceGroupName = $resourceGroup
ServiceName = $serviceName
Location = $service.location
Sku = $service.sku.name
UsesOAuth2 = $usesOAuth2
UsesOpenIdConnect = $usesOpenIdConnect
UsesClientCredentials = $usesClientCredentials
UsesLegacyKeysOnly = $usesLegacyKeysOnly
UsesBasicAuthentication = $usesBasicAuthentication
HasCentralEntraIntegration = $hasCentralEntraIntegration
AuthenticationMaturityScore = $score
}
}
return$results
}
functionTest-AuthenticationPatternsCompliance {
<#
.SYNOPSIS
Bepaalt de compliancestatus voor authenticatiepatronen rond API Management.
.OUTPUTS
PSCustomObject met samenvatting van de resultaten.
#>
[CmdletBinding()]
param()
$services = Get-ApiAuthenticationPatternStatusif (-not $services -or $services.Count -eq 0) {
Write-Verbose "Geen API Management-services gevonden in de geselecteerde scope."return [PSCustomObject]@{
ScriptName = "authentication-patterns"
IsCompliant = $true
Timestamp = Get-Date
Details = "Er zijn geen API Management-services gevonden in de huidige scope."
Recommendations = @()
Services = @()
}
}
$nonCompliant = $services | Where-Object { $_.AuthenticationMaturityScore -lt 75 }
$isCompliant = ($nonCompliant.Count -eq 0)
$details = if ($isCompliant) {
"Alle gevonden API Management-services beschikken over moderne authenticatie-indicatoren."
}
else {
"Een of meer API Management-services lijken nog gebruik te maken van legacy- of zwakke authenticatiepatronen (sleutelgebaseerde toegang, basis-authenticatie of ontbrekende centrale Entra-integratie)."
}
$recommendations = @()
if (-not $isCompliant) {
$recommendations += "Vervang sleutelgebaseerde toegang (subscription keys) zoveel mogelijk door tokengebaseerde authenticatie met Microsoft Entra ID."
$recommendations += "Schakel basis-authenticatie uit op alle productie-API's en migreer naar OAuth2/OpenID Connect met moderne clients."
$recommendations += "Richt centrale app-registraties in voor API's en standaardiseer scopes en app-rollen per risicoklasse."
$recommendations += "Documenteer gekozen authenticatiepatronen per API en koppel deze aan informatieclassificatie en BIO/AVG-eisen."
$recommendations += "Gebruik Infrastructure-as-Code om authenticatieconfiguraties reproduceerbaar en auditeerbaar te beheren."
}
return [PSCustomObject]@{
ScriptName = "authentication-patterns"
IsCompliant = $isCompliant
Timestamp = Get-Date
Details = $details
Recommendations = $recommendations
Services = $services
}
}
function Invoke-Monitoring {
<#
.SYNOPSIS
Voert een monitoring-run uit en toont de authenticatiepatroonstatus per API Management-service.
#>
[CmdletBinding()]
param()
Write-Host "`nMonitoring: $PolicyName" -ForegroundColor Yellow
Write-Host "Beschrijving: $PolicyDescription" -ForegroundColor Yellow
Write-Host "==============================================================" -ForegroundColor Yellow
$result = Test-AuthenticationPatternsCompliance$services = $result.Services
if ($services.Count -gt 0) {
Write-Host "`nGevonden API Management-services:" -ForegroundColor Cyan
foreach ($service in $services) {
$statusColor = if ($service.AuthenticationMaturityScore -ge 75) { "Green" } else { "Red" }
$statusText = "Maturity Score: $($service.AuthenticationMaturityScore)% - " +
"OAuth2: $(if ($service.UsesOAuth2) { 'Ja' } else { 'Nee' }), " +
"OIDC: $(if ($service.UsesOpenIdConnect) { 'Ja' } else { 'Nee' }), " +
"Client credentials: $(if ($service.UsesClientCredentials) { 'Ja' } else { 'Nee' }), " +
"Alleen keys: $(if ($service.UsesLegacyKeysOnly) { 'Ja' } else { 'Nee' }), " +
"Basic auth: $(if ($service.UsesBasicAuthentication) { 'Ja' } else { 'Nee' }), " +
"Centrale Entra-integratie: $(if ($service.HasCentralEntraIntegration) { 'Ja' } else { 'Nee' })"
Write-Host ("- {0}/{1} ({2}, {3}) - {4}" -f $service.SubscriptionName, $service.ServiceName, $service.Location, $service.Sku, $statusText) -ForegroundColor $statusColor
}
}
else {
Write-Host "`nGeen API Management-services gevonden in de huidige scope." -ForegroundColor Cyan
}
if ($result.IsCompliant) {
Write-Host "`nCOMPLIANT - Alle API Management-services beschikken over moderne authenticatie-indicatoren." -ForegroundColor Green
}
else {
Write-Host "`nNON-COMPLIANT - Eén of meer API Management-services gebruiken nog legacy- of zwakke authenticatiepatronen." -ForegroundColor Red
Write-Host "Aanbevolen acties:" -ForegroundColor Yellow
foreach ($rec in $result.Recommendations) {
Write-Host (" - {0}" -f $rec) -ForegroundColor Yellow
}
}
return$result
}
function Invoke-Remediation {
<#
.SYNOPSIS
Geeft een remediatie-overzicht voor services met onvoldoende volwassen authenticatiepatronen.
.DESCRIPTION
Voert zelf geen configuratiewijzigingen uit, maar biedt tekstuele
aanbevelingen die gebruikt kunnen worden in change- en IaC-processen.
#>
[CmdletBinding()]
param()
Write-Host "`nRemediatie: $PolicyName" -ForegroundColor Yellow
Write-Host "==============================================================" -ForegroundColor Yellow
$result = Test-AuthenticationPatternsCompliance$services = $result.Services | Where-Object { $_.AuthenticationMaturityScore -lt 75 }
if (-not $services -or $services.Count -eq 0) {
Write-Host "Alle API Management-services beschikken over voldoende volwassen authenticatiepatronen. Geen remediatie nodig." -ForegroundColor Green
return$result
}
Write-Host "`nNiet-conforme API Management-services (authenticatie onvoldoende volwassen):" -ForegroundColor Red
foreach ($service in $services) {
Write-Host ("- Subscription: {0}" -f $service.SubscriptionName) -ForegroundColor Red
Write-Host (" ResourceGroup: {0}" -f $service.ResourceGroupName) -ForegroundColor Red
Write-Host (" Service: {0}" -f $service.ServiceName) -ForegroundColor Red
Write-Host (" Locatie: {0}" -f $service.Location) -ForegroundColor Red
Write-Host (" SKU: {0}" -f $service.Sku) -ForegroundColor Red
Write-Host (" Score: {0}%" -f $service.AuthenticationMaturityScore) -ForegroundColor Red
Write-Host (" Alleen keys: {0}" -f $(if ($service.UsesLegacyKeysOnly) { 'Ja' } else { 'Nee' })) -ForegroundColor Red
Write-Host (" Basic auth: {0}" -f $(if ($service.UsesBasicAuthentication) { 'Ja' } else { 'Nee' })) -ForegroundColor Red
Write-Host ""
}
Write-Host "Aanbevolen vervolgstappen:" -ForegroundColor Yellow
foreach ($rec in $result.Recommendations) {
Write-Host (" - {0}" -f $rec) -ForegroundColor Yellow
}
if ($WhatIf) {
Write-Host "`nWhatIf is ingeschakeld: er worden geen wijzigingen doorgevoerd; alleen een rapport is gegenereerd." -ForegroundColor Cyan
}
return$result
}
try {
Write-Host "`n========================================" -ForegroundColor Cyan
Write-Host "Script: authentication-patterns" -ForegroundColor Cyan
Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan
Write-Host "========================================`n" -ForegroundColor Cyan
Connect-RequiredServices
if ($Monitoring) {
Invoke-Monitoring
}
elseif ($Remediation) {
Invoke-Remediation
}
else {
$result = Test-AuthenticationPatternsComplianceif ($result.IsCompliant) {
Write-Host "`nCOMPLIANT" -ForegroundColor Green
}
else {
Write-Host "`nNON-COMPLIANT" -ForegroundColor Red
Write-Host "Voer het script uit met -Monitoring of -Remediation voor meer details." -ForegroundColor Yellow
}
return$result
}
}
catch {
Write-Error "Er is een fout opgetreden in authentication-patterns.ps1: $_"
throw
}
finally {
Write-Host "`n========================================`n" -ForegroundColor Cyan
}
Risico zonder implementatie
Risico zonder implementatie
High: Zonder gestandaardiseerde authenticatiepatronen blijft het API-landschap gefragmenteerd en kwetsbaar. Verouderde patronen zoals basic authentication en gedeelde statische sleutels blijven bestaan, waardoor één misbruikte API toegang kan geven tot gevoelige gegevens of beheerinterfaces. Dit leidt tot verhoogd risico op datalekken, verstoringen van kritieke diensten en non-compliance met BIO, NIS2 en interne beveiligingsrichtlijnen.
Management Samenvatting
Ontwikkel en implementeer organisatiebrede authenticatiepatronen voor API's op basis van Microsoft Entra ID, OAuth2 en OpenID Connect. Gebruik Azure API Management policies om deze patronen technisch af te dwingen en benut het bijbehorende PowerShell-script om API Management-services te inventariseren en prioriteiten te bepalen. Zo ontstaat een consistent, toetsbaar en toekomstbestendig authenticatiefundament binnen de Nederlandse Baseline voor Veilige Cloud.