0Pricing
Security+ Academy · Lektion

Sichere Verwaltung von Secrets und Umgebungsvariablen

Vermeiden Sie fest im Quellcode hinterlegte Secrets, indem Sie Secrets Manager (Vault, AWS Secrets Manager) und die Injektion von Umgebungsvariablen zur Laufzeit verwenden.

Sichere Verwaltung von Secrets und Umgebungsvariablen ist eine kostenlose Security+ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Security+ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Security+ Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Problem fest im Code hinterlegter Secrets

Fest im Code hinterlegte Secrets – direkt im Quellcode eingebettete API-Schlüssel, Datenbankpasswörter, private TLS-Schlüssel und OAuth-Tokens – gehören zu den häufigsten und vermeidbarsten Sicherheitslücken. Secrets im Quellcode sind im Verlauf der Versionsverwaltung sichtbar (selbst nach ihrer Löschung), für alle Entwickler mit Zugriff auf das Repository einsehbar und werden häufig offengelegt, wenn Repositories versehentlich öffentlich gemacht werden. Tools wie GitGuardian und truffleHog durchsuchen Plattformen wie GitHub kontinuierlich nach offengelegten Secrets.

# 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 accidentally

Umgebungsvariablen: besser, aber nicht ausreichend

Umgebungsvariablen entfernen Secrets aus dem Quellcode, indem sie zur Laufzeit über das Host-Betriebssystem oder den Container-Orchestrator injiziert werden. Die Anwendung liest os.environ['DB_PASSWORD'] statt eines fest im Code hinterlegten Werts. Das ist besser als die direkte Hinterlegung im Quellcode, doch Umgebungsvariablen haben Schwächen: Sie erscheinen in Prozesslisten, werden an Kindprozesse vererbt, landen häufig in Crash-Dumps und Debugging-Protokollen und erfordern eine manuelle Rotation. Für die Entwicklung sind sie geeignet, für das Secrets-Management in der Produktion allein jedoch nicht ausreichend.

# 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>/environ

Dedizierte Secrets Manager

Secrets Manager sind speziell entwickelte Systeme zum Speichern, Rotieren und Auditieren des Zugriffs auf Secrets. Zu den führenden Lösungen gehören HashiCorp Vault (Open Source und Enterprise), AWS Secrets Manager, Azure Key Vault und Google Cloud Secret Manager. Anwendungen authentifizieren sich zur Laufzeit beim Secrets Manager, rufen das Secret ab und verwenden es – Secrets werden niemals auf der Festplatte oder in Umgebungsvariablen gespeichert. Jeder Zugriff wird protokolliert, sodass nachvollzogen werden kann, wer wann auf welches Secret zugegriffen hat.

# 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 Secret-Rotation

Ein wesentlicher Vorteil von Secrets Managern gegenüber Umgebungsvariablen ist die automatische Rotation. AWS Secrets Manager kann die Passwörter von RDS-Datenbanken planmäßig automatisch rotieren (z. B. alle 30 Tage), ohne dass die Anwendung erneut bereitgestellt werden muss. Der Secrets Manager aktualisiert das Passwort in der Datenbank und gleichzeitig das gespeicherte Secret. Anwendungen, die Secrets bei jeder Verbindung abrufen, erhalten automatisch das neue Zugangselement. Dadurch entfällt die verbreitete Praxis, „dauerhafte“ Passwörter für Servicekonten zu verwenden, die niemals rotiert werden.

# 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 value

Die Schutzmaßnahme .gitignore

Die erste Verteidigungslinie gegen committete Secrets ist eine ordnungsgemäß gepflegte .gitignore-Datei, die alle Dateien ausschließt, die Secrets enthalten könnten. .gitignore verhindert jedoch nur zukünftige Commits – bereits committete Secrets bleiben in der Git-Historie erhalten. Wenn Secrets versehentlich committet wurden, müssen sie sofort als kompromittiert behandelt werden: Rotieren Sie das Secret und verwenden Sie anschließend optional Tools wie git filter-repo, um die Historie umzuschreiben (für die Compliance erforderlich, allein jedoch nicht ausreichend, da das Secret möglicherweise bereits extrahiert wurde).

# 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 / truffleHog

Secrets in Infrastructure as Code

Infrastructure-as-Code-Dateien (IaC-Dateien) (Terraform, CloudFormation, Kubernetes-Manifeste) enthalten häufig Secrets – Datenbankverbindungszeichenfolgen, API-Schlüssel in Deklarationen von Umgebungsvariablen und TLS-Zertifikate. Diese Dateien werden oft in die Versionsverwaltung übernommen, wodurch das Risiko einer Offenlegung von Secrets entsteht. Zu den Lösungen gehören dynamische Vault-Secrets (Vault generiert speziell für jeden Terraform-Lauf ein kurzlebiges Zugangstoken), Kubernetes Secrets (in etcd gespeichert und bei der Speicherung zwingend zu verschlüsseln) sowie der external-secrets-operator, der Secrets zur Laufzeit aus einem Secrets Manager nach Kubernetes synchronisiert.

Prinzip der geringsten Berechtigungen für Secrets

Jede Anwendung bzw. jeder Dienst sollte nur auf die Secrets zugreifen, die er konkret benötigt – das Prinzip der geringsten Berechtigungen, angewendet auf Secrets. Eine Webanwendung benötigt das Datenbankpasswort, aber nicht den privaten CA-Schlüssel. Ein Reporting-Job benötigt schreibgeschützte Datenbankzugangsdaten und keinen Schreibzugriff. Secrets Manager setzen dies mithilfe von Zugriffsrichtlinien durch, die festlegen, welche Identitäten (IAM-Rollen, Servicekonten, AppRoles) welche Secrets lesen dürfen; sämtliche Zugriffe werden zu Prüfzwecken protokolliert.

# 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 Secrets

Dynamische Secrets werden bei Bedarf für einen bestimmten Anforderer generiert und laufen automatisch ab. Vault kann ein temporäres Datenbankzugangstoken generieren, das 1 Stunde lang gültig und dem konkreten Dienst zugeordnet ist, der es angefordert hat. Nach Ablauf wird das Zugangstoken von der Datenbank automatisch widerrufen. Dadurch gibt es keine langlebigen statischen Zugangsdaten, die gestohlen werden könnten – selbst wenn ein Angreifer ein dynamisches Zugangstoken abfängt, läuft es schnell ab und ist in den Audit-Logs an die anfordernde Identität gebunden.

# 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.

Secrets in CI/CD-Pipelines

CI/CD-Pipelines benötigen häufig Secrets – Anmeldedaten von Cloud-Anbietern für Deployments, Docker-Registry-Token und Signaturschlüssel. Speichern Sie Secrets niemals in Pipeline-Skripten oder Konfigurationsdateien. Verwenden Sie stattdessen den integrierten Secret Store der Pipeline-Plattform (GitHub Actions Secrets, GitLab CI Variables, Jenkins Credentials Store) oder rufen Sie Secrets zur Laufzeit mithilfe einer Maschinenidentität aus einem zentralen Vault ab. Markieren Sie Secret-Variablen in Logs als maskiert, um eine versehentliche Offenlegung in der Build-Ausgabe zu verhindern.

# 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 all

Zugriffe auf Secrets überwachen

Secrets Manager stellen umfassende Audit-Logs für jedes Zugriffsereignis auf ein Secret bereit: welche Identität auf welches Secret zugegriffen hat, von welcher IP-Adresse, zu welchem Zeitpunkt und ob der Zugriff erfolgreich war oder verweigert wurde. Diese Logs sind für Compliance (SOC 2, PCI-DSS) und die Reaktion auf Sicherheitsvorfälle von entscheidender Bedeutung. Wenn der Verdacht besteht, dass ein Zugangstoken kompromittiert wurde, zeigen die Audit-Logs, welche Systeme wann darauf zugegriffen haben – dadurch lassen sich potenziell betroffene Systeme schnell identifizieren und Maßnahmen zur Eindämmung festlegen.

Pre-Commit-Hooks zur Vermeidung von Secrets

Pre-Commit-Hooks sind Skripte, die automatisch ausgeführt werden, bevor ein Git-Commit endgültig erstellt wird. Dadurch können Secrets erkannt werden, bevor sie in die Versionsverwaltung gelangen. Tools wie detect-secrets (Yelp), GitLeaks und git-secrets (AWS) lassen sich als Pre-Commit-Hooks integrieren und durchsuchen bereitgestellte Dateien nach Mustern, die API-Schlüsseln, Verbindungszeichenfolgen, privaten Schlüsseln und JWT-Token entsprechen. Wird ein Secret erkannt, wird der Commit abgelehnt und die Entwicklerin bzw. der Entwickler aufgefordert, die Zugangsdaten zu entfernen. Das pre-commit-Framework erleichtert das Hinzufügen und Teilen von Hook-Konfigurationen in 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 manager

Kurzer Wissenstest

Testen Sie Ihr Verständnis der CompTIA-Security+-Konzepte (SY0-701) aus dieser Lektion.

Lektionszusammenfassung

In dieser Lektion haben Sie gelernt: Hartcodierte Secrets im Quellcode müssen entfernt und durch Secrets Manager wie Vault oder AWS Secrets Manager ersetzt werden, die automatische Rotation entfernt langlebige Zugangsdaten, die Angreifer selbst nach einer anfänglichen Kompromittierung missbrauchen könnten, und dynamische Secrets sowie Zugriffsrichtlinien nach dem Prinzip der geringsten Berechtigungen verringern den Wert jedes einzelnen offengelegten Secrets. Als Nächstes beschäftigen wir uns mit der Sicherheit von Abhängigkeiten und der Software Composition Analysis.

Häufig gestellte Fragen

Ist die Lektion „Sichere Verwaltung von Secrets und Umgebungsvariablen“ kostenlos?

Ja — der vollständige Text von „Sichere Verwaltung von Secrets und Umgebungsvariablen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Security+ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Security+ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Sichere Verwaltung von Secrets und Umgebungsvariablen“?

Vermeiden Sie fest im Quellcode hinterlegte Secrets, indem Sie Secrets Manager (Vault, AWS Secrets Manager) und die Injektion von Umgebungsvariablen zur Laufzeit verwenden. Du übst Security+ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Security+ Academy zu starten?

Keine Vorkenntnisse erforderlich. Security+ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Sichere Verwaltung von Secrets und Umgebungsvariablen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Security+ Academy-Lektion Code schreiben und ausführen?

Ja. Jede Security+ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Eingabevalidierung und Ausgabekodierung
  2. Sichere Verwaltung von Secrets und Umgebungsvariablen
  3. Abhängigkeitssicherheit und Software Composition Analysis
  4. DevSecOps: Sicherheit in Pipelines nach links verlagern
← Zurück zu Security+ Academy