Veilig beheer van secrets en omgevingsvariabelen
Vermijd hardcoded secrets in broncode door secretsmanagers (Vault, AWS Secrets Manager) en injectie van omgevingsvariabelen tijdens runtime te gebruiken.
Veilig beheer van secrets en omgevingsvariabelen is een gratis Security+ Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Security+ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Security+ Academy bevat in totaal 4 lessen.
Het probleem met hardgecodeerde geheimen
Hardgecodeerde geheimen — API-sleutels, databasewachtwoorden, privésleutels voor TLS en OAuth-tokens die rechtstreeks in broncode zijn opgenomen — behoren tot de meest voorkomende en eenvoudigst te voorkomen beveiligingskwetsbaarheden. Geheimen in broncode worden blootgesteld in de geschiedenis van versiebeheer (zelfs nadat ze zijn verwijderd), zijn zichtbaar voor alle ontwikkelaars met toegang tot de repository en lekken vaak uit wanneer repositories per ongeluk openbaar worden gemaakt. Hulpmiddelen zoals GitGuardian en truffleHog scannen voortdurend naar gelekte geheimen op platforms zoals GitHub.
# DANGEROUS: hardcoded secret in source code
# db_password = 'P@ssw0rd#2026'
# api_key = 'sk-live-abc123xyz789'
# aws_secret = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
# These secrets are now:
# - In git history (even if later deleted)
# - Visible to all repo contributors
# - Potentially in CI/CD logs
# - Often leaked when repos go public accidentallyOmgevingsvariabelen: beter, maar niet voldoende
Omgevingsvariabelen verwijderen geheimen uit de broncode door ze tijdens runtime te injecteren via het hostbesturingssysteem of de containerorchestrator. De applicatie leest os.environ['DB_PASSWORD'] in plaats van een hardgecodeerde waarde. Dit is beter dan hardcoderen, maar omgevingsvariabelen hebben zwakke punten: ze verschijnen in proceslijsten, worden overgenomen door kindprocessen, belanden vaak in crashdumps en foutopsporingslogboeken en vereisen handmatige rotatie. Ze zijn geschikt voor ontwikkeling, maar op zichzelf niet voldoende voor het beheer van productiegeheimen.
# Environment variable pattern:
# In .env file (NEVER commit to git):
# DB_PASSWORD=P@ssw0rd#2026
# API_KEY=sk-live-abc123xyz789
# In .gitignore:
# .env
# *.env
# .env.*
# In application code:
# db_password = os.environ.get('DB_PASSWORD')
# api_key = os.environ.get('API_KEY')
# Risk: env vars visible in 'ps aux' output,
# inherited by child processes, appear in /proc/<pid>/environSpeciale beheerders van geheimen
Beheerders van geheimen zijn speciaal ontwikkelde systemen voor het opslaan, roteren en controleren van toegang tot geheimen. Toonaangevende oplossingen zijn onder andere HashiCorp Vault (open source en enterprise), AWS Secrets Manager, Azure Key Vault en Google Cloud Secret Manager. Applicaties authenticeren tijdens runtime bij de beheerder van geheimen, halen het geheim op en gebruiken het — geheimen worden nooit op schijf of in omgevingsvariabelen opgeslagen. Alle toegang wordt vastgelegd in logboeken, zodat kan worden gecontroleerd wie welk geheim en wanneer heeft geraadpleegd.
# HashiCorp Vault secret retrieval (conceptual):
# Application authenticates to Vault using:
# - AWS IAM role (in cloud environments)
# - Kubernetes service account token
# - AppRole credentials
# After authentication, retrieve secret:
# vault kv get -field=password secret/prod/database
# In application (Python SDK):
# client = hvac.Client(url='https://vault.company.com')
# client.auth.aws.iam_login(role='prod-app')
# secret = client.secrets.kv.read_secret('prod/database')
# db_password = secret['data']['password']Automatische rotatie van geheimen
Een belangrijk voordeel van beheerders van geheimen ten opzichte van omgevingsvariabelen is automatische rotatie. AWS Secrets Manager kan wachtwoorden van RDS-databases automatisch volgens een schema roteren (bijvoorbeeld elke 30 dagen), zonder dat de applicatie opnieuw hoeft te worden geïmplementeerd. De beheerder van geheimen werkt het wachtwoord in de database bij en werkt tegelijkertijd het opgeslagen geheim bij. Applicaties die bij elke verbinding geheimen ophalen, ontvangen automatisch de nieuwe aanmeldingsgegevens. Zo verdwijnt de gangbare praktijk van 'permanente' wachtwoorden voor serviceaccounts die nooit worden geroteerd.
# AWS Secrets Manager rotation configuration:
# Secret: prod/app-database-credentials
# Rotation: enabled
# Frequency: every 30 days
# Lambda function: SecretsManager-MyRDSRotation
# Rotation process:
# 1. Lambda creates new DB password
# 2. Updates secret in Secrets Manager
# 3. Updates password on RDS instance
# 4. Tests new credentials work
# 5. Deprecates old credentials
# Application: always calls GetSecretValue at runtime -> gets fresh valueDe verdediging van .gitignore
De eerste verdedigingslinie tegen geheimen die worden vastgelegd, is een goed onderhouden .gitignore-bestand dat alle bestanden uitsluit die geheimen kunnen bevatten. .gitignore voorkomt echter alleen toekomstige vastleggingen — geheimen die al zijn vastgelegd, blijven in de git-geschiedenis staan. Als geheimen per ongeluk worden vastgelegd, moet je er onmiddellijk van uitgaan dat ze zijn gecompromitteerd: roteer het geheim en gebruik eventueel hulpmiddelen zoals git filter-repo om de geschiedenis te herschrijven (vereist voor naleving, maar op zichzelf onvoldoende omdat het geheim mogelijk al is buitgemaakt).
# Recommended .gitignore entries for secret files:
# .env
# .env.*
# *.pem
# *.key
# *.p12
# *.pfx
# credentials.json
# service_account*.json
# secrets.yaml
# config/secrets.yml
# terraform.tfvars (may contain cloud credentials)
# .aws/credentials
# Pre-commit hook to scan for secrets before commit:
# pre-commit install
# hook: detect-secrets / gitleaks / truffleHogGeheimen in infrastructuur als code
Bestanden voor infrastructuur als code (IaC) (Terraform, CloudFormation, Kubernetes-manifesten) bevatten vaak geheimen — verbindingsreeksen voor databases, API-sleutels in declaraties van omgevingsvariabelen en TLS-certificaten. Deze bestanden worden vaak vastgelegd in versiebeheer, waardoor het risico ontstaat dat geheimen worden blootgesteld. Oplossingen zijn onder andere dynamische geheimen van Vault (Vault genereert specifiek voor elke Terraform-uitvoering een referentie met een korte levensduur), Kubernetes Secrets (opgeslagen in etcd en versleuteld tijdens opslag) en external-secrets-operator, die tijdens runtime synchroniseert vanuit een geheimenbeheerder naar Kubernetes.
Principe van minimale bevoegdheden voor geheimen
Elke toepassing of service mag alleen toegang hebben tot de geheimen die deze specifiek nodig heeft — het principe van minimale bevoegdheden toegepast op geheimen. Een webtoepassing heeft het databasewachtwoord nodig, maar niet de persoonlijke sleutel van de CA. Een rapportagetaak heeft alleen-lezenreferenties voor de database nodig, geen schrijftoegang. Geheimenbeheerders dwingen dit af met toegangsbeleid waarin staat welke identiteiten (IAM-rollen, serviceaccounts, AppRoles) welke geheimen mogen lezen. Alle toegang wordt vastgelegd voor controledoeleinden.
# Vault policy: web application can read DB password only
# policy name: web-app-policy
# path 'secret/prod/database' {
# capabilities = ['read']
# }
# path 'secret/prod/tls-certs/*' {
# capabilities = [] # DENY - app does not need TLS keys
# }
# This policy is assigned to the web app's AppRole.
# The reporting service gets a separate policy with
# only 'secret/prod/reporting-db-readonly' access.Dynamische geheimen
Dynamische geheimen worden op aanvraag gegenereerd voor een specifieke aanvrager en verlopen automatisch. Vault kan een tijdelijke database-referentie genereren die 1 uur geldig is en is gekoppeld aan de specifieke service die erom heeft gevraagd. Na het verlopen wordt de referentie automatisch ingetrokken door de database. Hierdoor zijn er geen statische referenties met een lange levensduur die kunnen worden gestolen — zelfs als een aanvaller een dynamische referentie onderschept, verloopt deze snel en is deze in de controleregisters gekoppeld aan de identiteit van de aanvrager.
# Vault dynamic secrets: temporary DB credentials
# Application calls Vault to get a DB credential:
# vault read database/creds/web-app-role
#
# Vault response:
# username: v-web-app-x7k2m-1234567890 (unique, temporary)
# password: A1b2C3d4E5f6G7h8 (randomly generated)
# lease_duration: 1h (auto-expires)
#
# After 1 hour, Vault instructs DB to revoke this user.
# No static password ever exists for the attacker to steal.Geheimen in CI/CD-pijplijnen
CI/CD-pijplijnen hebben vaak geheimen nodig — referenties van cloudproviders voor implementatie, tokens voor Docker-registers en ondertekeningssleutels. Sla geheimen nooit op in pijplijnscripts of configuratiebestanden. Gebruik in plaats daarvan de ingebouwde geheimenopslag van het pij platform (GitHub Actions Secrets, GitLab CI Variables, Jenkins Credentials Store) of haal tijdens runtime geheimen op uit een centrale kluis met behulp van een machine-identiteit. Markeer geheimvariabelen als gemaskeerd in logboeken om te voorkomen dat ze per ongeluk in de uitvoer van een build zichtbaar worden.
# GitHub Actions: using secrets in pipeline
# secrets.yml in GitHub Settings -> Secrets (encrypted storage)
# Secret: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
# In .github/workflows/deploy.yml:
# env:
# AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
# AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
# Best practice: use OIDC federation instead
# GitHub -> AWS trust relationship via OIDC token
# -> No static AWS keys needed at allToegang tot geheimen controleren
Geheimenbeheerders leveren uitgebreide controleregisters van elke gebeurtenis waarbij toegang tot een geheim plaatsvindt: welke identiteit welk geheim heeft benaderd, vanaf welk IP-adres, op welk tijdstip en of de toegang geslaagd of geweigerd was. Deze logboeken zijn essentieel voor naleving (SOC 2, PCI-DSS) en voor het reageren op incidenten. Wanneer wordt vermoed dat een referentie is gecompromitteerd, laten de controleregisters zien welke systemen deze hebben gebruikt en wanneer — zodat je mogelijk getroffen systemen snel kunt identificeren en beslissingen over indamming kunt nemen.
Pre-commit-hooks om geheimen te voorkomen
Pre-commit-hooks zijn scripts die automatisch worden uitgevoerd voordat elke git-commit definitief wordt gemaakt. Zo kunnen geheimen worden gedetecteerd voordat ze in de geschiedenis van het versiebeheer terechtkomen. Hulpmiddelen zoals detect-secrets (Yelp), GitLeaks en git-secrets (AWS) kunnen als pre-commit-hooks worden geïntegreerd en geënsceneerde bestanden scannen op patronen die overeenkomen met API-sleutels, verbindingsreeksen, persoonlijke sleutels en JWT-tokens. Als een geheim wordt gedetecteerd, wordt de commit geweigerd en krijgt de ontwikkelaar het verzoek de referentie te verwijderen. Met het pre-commit-framework kun je hookconfiguraties eenvoudig toevoegen en delen binnen teams.
# Installing detect-secrets as pre-commit hook:
# 1. Install: pip install detect-secrets
# 2. Create baseline: detect-secrets scan > .secrets.baseline
# 3. Add to .pre-commit-config.yaml:
# repos:
# - repo: https://github.com/Yelp/detect-secrets
# rev: v1.4.0
# hooks:
# - id: detect-secrets
# args: ['--baseline', '.secrets.baseline']
# 4. Install hooks: pre-commit install
# Now every commit attempt is scanned:
# git commit -m 'add config'
# -> detect-secrets runs
# -> if AWS key pattern found: COMMIT BLOCKED
# -> developer must remove secret and use secrets managerKorte controle
Test je begrip van de CompTIA Security+-concepten (SY0-701) uit deze les.
Samenvatting van de les
In deze les heb je geleerd dat hardgecodeerde geheimen in broncode moeten worden verwijderd en vervangen door geheimenbeheerders zoals Vault of AWS Secrets Manager, dat automatische rotatie referenties met een lange levensduur verwijdert die aanvallers zelfs na een eerste compromittering kunnen misbruiken, en dat dynamische geheimen en toegangsbeleid met minimale bevoegdheden de waarde beperken van elk afzonderlijk geheim dat wordt blootgesteld. Hierna bekijken we beveiliging van afhankelijkheden en analyse van softwaresamenstelling.
Leer Security+ Academy met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “Veilig beheer van secrets en omgevingsvariabelen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Security+ Academy, waaronder “Veilig beheer van secrets en omgevingsvariabelen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Security+ Academy bevat in totaal 4 lessen.
Wat leer ik in “Veilig beheer van secrets en omgevingsvariabelen”?
Vermijd hardcoded secrets in broncode door secretsmanagers (Vault, AWS Secrets Manager) en injectie van omgevingsvariabelen tijdens runtime te gebruiken. Je oefent met Security+ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Security+ Academy te beginnen?
Ervaring vooraf is niet nodig. Security+ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Veilig beheer van secrets en omgevingsvariabelen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Security+ Academy?
Ja. Elke les over Security+ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Invoervalidatie en uitvoercodering
- Veilig beheer van secrets en omgevingsvariabelen
- Dependencybeveiliging en software composition analysis
- DevSecOps: beveiliging naar links verschuiven in pipelines