In Softwareentwicklungsprozessen benötigen Anwendungen sensible Daten (Geheimnisse) wie API-Schlüssel, Datenbank-Zugangsdaten, Passwörter und Zertifikate, um ordnungsgemäß zu funktionieren. Das Speichern dieser Geheimnisse im Code, in Konfigurationsdateien oder Umgebungsvariablen birgt jedoch erhebliche Sicherheitsrisiken. Lecks, unbefugter Zugriff oder Fehlkonfigurationen können zu großen Datenlecks führen.

Warum traditionelle Methoden nicht ausreichen?

• Umgebungsvariablen: Oft in Prozesslisten sichtbar, schwierig in verteilten Systemen zu verwalten.
• Konfigurationsdateien: Können versehentlich in Quellcodeverwaltungssysteme (wie Git) committet werden und sind unbefugtem Zugriff ausgesetzt.
• Hardcodierung im Code: Eine der schlechtesten Praktiken, die eine Neukompilierung des Codes erfordert, wenn Geheimnisse geändert oder aktualisiert werden müssen.

Um diese Probleme zu lösen, benötigen wir eine zentralisierte Lösung zur Geheimnisverwaltung wie HashiCorp Vault. Vault wurde entwickelt, um alle Geheimnisse, die Ihre Anwendungen benötigen, sicher zu speichern, darauf zuzugreifen und zu verwalten.

Was ist HashiCorp Vault?

HashiCorp Vault ist ein Tool, das die zentralisierte Speicherung von Geheimnissen, Zugriffskontrolle und Verschlüsselungsdienste bietet. Es ermöglicht Entwicklern den sicheren Zugriff auf sensible Informationen, die in ihren Anwendungen verwendet werden. Zu den Hauptmerkmalen von Vault gehören:

• Geheimnisspeicher: Kann Schlüssel/Wert-Paare, dynamische Geheimnisse (Datenbank-Zugangsdaten), Zertifikate usw. speichern.
• Datenverschlüsselung: Bietet eine API für Datenverschlüsselungs-/Entschlüsselungsvorgänge und bietet Verschlüsselungsdienste, ohne dass die Daten selbst in Vault gespeichert werden müssen.
• Zugriffskontrolle: Definiert mit detaillierten Richtlinien (ACL), wer wie lange auf welches Geheimnis zugreifen kann.
• Audit-Log: Überwacht alle Zugriffe auf Geheimnisse und Verwaltungsvorgänge.

Grundlegende Vault-Einrichtung und Verwendung für Entwickler (lokale Umgebung)

Das Starten von Vault im dev-Modus in Ihrer lokalen Entwicklungsumgebung ist recht einfach. Dieser Modus dient Test- und Lernzwecken; für Produktionsumgebungen ist eine andere Konfiguration erforderlich.

vault server -dev -dev-listen-address="0.0.0.0:8200"

Dieser Befehl startet Vault im Entwicklungsmodus und zeigt standardmäßig den Root-Token an. Sie können sich mit diesem Token bei Vault anmelden:

export VAULT_ADDR='http://127.0.0.1:8200' # Standard 127.0.0.1:8200, wenn dev-listen-address nicht verwendet wurde.

vault login <root_token>

Verwenden der KV Secrets Engine (Schlüssel/Wert-Speicher)

Eine der am häufigsten verwendeten Geheimnis-Engines ist die KV (Key/Value)-Engine. Sie ist ideal zum Speichern statischer Geheimnisse wie Anwendungskonfigurationen und API-Schlüssel. Die KV-v2-Engine bietet Versionsunterstützung.

Aktivieren wir zuerst die KV-v2-Engine:

vault secrets enable -version=2 kv

Erstellen wir nun ein Geheimnis. Zum Beispiel einen API-Schlüssel und einen Datenbank-Benutzernamen für unsere Anwendung:

vault kv put kv/myapp/config api_key="superSecretAPIKey123" db_user="app_admin" db_password="Pa$$w0rd"

Um dieses Geheimnis zu lesen:

vault kv get kv/myapp/config

--- Key --- Value ---version     1api_key     superSecretAPIKey123db_password Pa$$w0rddb_user     app_admin

Geheimnisse mit einer Python-Anwendung abrufen

Sehen wir uns nun an, wie diese Geheimnisse über eine Python-Anwendung abgerufen werden können. Wir verwenden die hvac-Bibliothek.

pip install hvac

import hvacimport os# Vault-Server-AdresseVAULT_ADDR = os.getenv('VAULT_ADDR', 'http://127.0.0.1:8200')# Im Entwicklungsmodus verwenden wir den Root-Token. In der Produktion sollten sicherere Methoden bevorzugt werden.VAULT_TOKEN = os.getenv('VAULT_TOKEN', '<hier_ihr_root_token>') # Ersetzen Sie dies durch Ihren Root-Tokenclient = hvac.Client(url=VAULT_ADDR, token=VAULT_TOKEN)if client.is_authenticated():    print("Erfolgreich mit Vault verbunden!")    try:        read_response = client.secrets.kv.v2.read_secret_version(            mount_point='kv',            path='myapp/config'        )        api_key = read_response['data']['data']['api_key']        db_user = read_response['data']['data']['db_user']        db_password = read_response['data']['data']['db_password']        print(f"API-Schlüssel: {api_key}")        print(f"DB-Benutzer: {db_user}")        print(f"DB-Passwort: {db_password}")    except Exception as e:        print(f"Fehler beim Lesen des Geheimnisses: {e}")else:    print("Vault-Authentifizierung fehlgeschlagen.")

Wichtiger Hinweis: In Produktionsumgebungen sollten Sie anstelle des root_token eine der verschiedenen von Vault bereitgestellten Authentifizierungsmethoden (z. B. AppRole, Kubernetes Service Account) verwenden. Dieses Beispiel veranschaulicht das grundlegende Funktionsprinzip.

Richtlinienverwaltung (ACL)

Alles in Vault basiert auf Richtlinien (ACL - Access Control List). Sie definieren mithilfe von Richtlinien, wer mit welchen Berechtigungen auf welchen Pfad zugreifen kann. Erstellen wir beispielsweise eine Richtlinie, die nur Lesezugriff für den Pfad myapp-config gewährt.

Erstellen wir eine Datei namens myapp-policy.hcl:

path "kv/data/myapp/config" {  capabilities = ["read"]}

Schreiben Sie diese Richtlinie in Vault:

vault policy write myapp-readonly myapp-policy.hcl

Indem wir diese Richtlinie nun mit einem Token oder einer Authentifizierungsmethode (z. B. einer AppRole) verknüpfen, können wir sicherstellen, dass nur Benutzer/Anwendungen, die durch diese Richtlinie autorisiert sind, Geheimnisse aus dem Pfad kv/data/myapp/config lesen können.

Dynamische Geheimnisse: Datenbank-Zugangsdaten

Eine der mächtigsten Funktionen von Vault sind dynamische Geheimnisse. Mit dieser Funktion können Anwendungen Zugangsdaten erhalten, die bei Bedarf erstellt werden, kurzlebig sind und nur für diese spezifische Anfrage gültig sind. Zum Beispiel können wir dynamische Benutzer für eine Datenbank erstellen. Auf diese Weise wird das Risiko minimiert, selbst wenn ein Geheimnis kompromittiert wird, da seine Lebensdauer kurz ist.

Aktivieren wir die dynamische Geheimnis-Engine für PostgreSQL:

vault secrets enable postgresql

Konfigurieren Sie die Datenbankverbindungsinformationen (dieses Beispiel geht davon aus, dass PostgreSQL auf Docker läuft):

vault write postgresql/config/connection connection_url="postgresql://{{username}}:{{password}}@localhost:5432/mydb"

Definieren wir nun eine Rolle. Diese Rolle erstellt einen neuen Datenbankbenutzer für eine bestimmte Dauer (z. B. 1 Minute):

vault write postgresql/roles/my-app-role 
oles="myapp_read_only" 	tl="1m" 
enewal_period="1m" 
ative_tls=false 
evoke_on_delete=true 
evocation_sql="DROP USER IF EXISTS "{{name}}" CASCADE;" \
creation_statements="CREATE ROLE "{{name}}" WITH LOGIN PASSWORD '{{password}}' VALID UNTIL '{{expiration}}'; GRANT SELECT ON ALL TABLES IN SCHEMA public TO "{{name}}";"

Fordern Sie dynamische Zugangsdaten von dieser Rolle an:

vault read postgresql/creds/my-app-role

Key                Value---                -----lease_id           postgresql/creds/my-app-role/<UUID>lease_duration     1mlease_renewable    truedata              map[password:g9e...N92 username:v-token-my-app-role-<UUID>]

Wie Sie sehen, hat Vault automatisch einen Benutzernamen und ein Passwort generiert, und diese Zugangsdaten sind nur 1 Minute lang gültig. Ihre Anwendung stellt mithilfe dieser Zugangsdaten eine Verbindung zur Datenbank her, und wenn die Zeit abläuft, kann Vault diesen Benutzer automatisch widerrufen oder erneuern.

Fazit

HashiCorp Vault ist ein leistungsstarkes Tool, das die Geheimnisverwaltung in modernen Anwendungen sicher und skalierbar macht. Indem Sie die Sicherheitslücken von Umgebungsvariablen oder Konfigurationsdateien beseitigen, können Sie Ihre Geheimnisse von einem zentralen Ort aus verwalten, Zugriffsrichtlinien durchsetzen und sogar dynamische, kurzlebige Zugangsdaten erstellen. Als Softwareentwickler müssen wir solche Tools in unseren SDLC (Software Development Life Cycle) integrieren, um sicherere Anwendungen zu erstellen.