Wie kann ich meine geheimen Schlüssel und mein Passwort sicher in meinem Versionskontrollsystem speichern?

Ich behalte wichtige Einstellungen wie die Hostnamen und Ports von Entwicklungs- und Produktionsservern in meinem Versionskontrollsystem. Aber ich weiß, dass es eine schlechte Praxis ist , Geheimnisse (wie private Schlüssel und Datenbankkennwörter) in einem VCS-Repository aufzubewahren.

Passwörter scheinen jedoch - wie jede andere Einstellung - versioniert zu sein. Was ist also der richtige Weg, um die Versionskontrolle von Passwörtern aufrechtzuerhalten?

Ich stelle mir vor, es würde bedeuten, die Geheimnisse in ihrer eigenen Datei "Geheimnisseeinstellungen" zu behalten und diese Datei verschlüsseln und versionieren zu lassen. Aber welche Technologien? Und wie macht man das richtig? Gibt es einen besseren Weg, dies zu tun?

Ich stelle die Frage allgemein, aber in meinem speziellen Fall möchte ich geheime Schlüssel und Passwörter für eine Django / Python- Site mit git und github speichern .

Eine ideale Lösung würde auch etwas Magisches bewirken, wenn ich mit git drücke / ziehe - z. B. wenn sich die verschlüsselte Kennwortdatei ändert, wird ein Skript ausgeführt, das nach einem Kennwort fragt und es entschlüsselt.

Sie sind genau richtig, wenn Sie Ihre vertrauliche Einstellungsdatei verschlüsseln möchten, während die Datei weiterhin in der Versionskontrolle bleibt. Wie Sie bereits erwähnt haben, ist die beste Lösung eine, bei der Git bestimmte vertrauliche Dateien transparent verschlüsselt, wenn Sie sie pushen, sodass Sie lokal (dh auf jedem Computer mit Ihrem Zertifikat) die Einstellungsdatei verwenden können, aber Git oder Dropbox oder wer auch immer Das Speichern Ihrer Dateien unter VC kann die Informationen nicht im Klartext lesen.

Tutorial zur transparenten Verschlüsselung / Entschlüsselung beim Push / Pull

Diese Zusammenfassung https://gist.github.com/873637 zeigt ein Tutorial zur Verwendung des Smudge / Clean-Filtertreibers des Git mit openssl zum transparenten Verschlüsseln von Push-Dateien. Sie müssen nur eine Ersteinrichtung vornehmen.

Zusammenfassung der Funktionsweise

Sie erstellen im Grunde einen .gitencryptOrdner mit 3 Bash-Skripten.

clean_filter_openssl 
smudge_filter_openssl 
diff_filter_openssl 

die von Git zur Entschlüsselung, Verschlüsselung und Unterstützung von Git diff verwendet werden. In diesen Skripten ist eine Master-Passphrase und ein Salt (behoben!) Definiert, und Sie MÜSSEN sicherstellen, dass .gitencrypt niemals tatsächlich gepusht wird. Beispielskript clean_filter_openssl:

#!/bin/bash

SALT_FIXED=<your-salt> # 24 or less hex characters
PASS_FIXED=<your-passphrase>

openssl enc -base64 -aes-256-ecb -S $SALT_FIXED -k $PASS_FIXED

Ähnliches gilt für smudge_filter_open_sslund diff_filter_oepnssl. Siehe Gist.

Ihr Repo mit vertraulichen Informationen sollte eine Gitattribute-Datei (unverschlüsselt und im Repo enthalten) enthalten, die auf das .gitencrypt-Verzeichnis verweist (das alles enthält, was Git zum transparenten Ver- / Entschlüsseln des Projekts benötigt) und auf Ihrem lokalen Computer vorhanden ist.

.gitattribute Inhalt:

* filter=openssl diff=openssl
[merge]
    renormalize = true

Schließlich müssen Sie Ihrer .git/configDatei auch den folgenden Inhalt hinzufügen

[filter "openssl"]
    smudge = ~/.gitencrypt/smudge_filter_openssl
    clean = ~/.gitencrypt/clean_filter_openssl
[diff "openssl"]
    textconv = ~/.gitencrypt/diff_filter_openssl

Wenn Sie nun das Repository mit Ihren vertraulichen Informationen in ein Remote-Repository verschieben, werden die Dateien transparent verschlüsselt. Wenn Sie von einem lokalen Computer mit dem Verzeichnis .gitencrypt (mit Ihrer Passphrase) abrufen, werden die Dateien transparent entschlüsselt.

Anmerkungen

Ich sollte beachten, dass dieses Tutorial keine Möglichkeit beschreibt, nur Ihre vertraulichen Einstellungsdatei zu verschlüsseln. Dadurch wird das gesamte Repository, das auf den Remote-VC-Host übertragen wird, transparent verschlüsselt und das gesamte Repository entschlüsselt, sodass es lokal vollständig entschlüsselt wird. Um das gewünschte Verhalten zu erzielen, können Sie vertrauliche Dateien für ein oder mehrere Projekte in einem sensitive_settings_repo ablegen. Sie können untersuchen, wie diese transparente Verschlüsselungstechnik mit Git-Submodulen funktioniert: http://git-scm.com/book/en/Git-Tools-Submodules, wenn sich die vertraulichen Dateien wirklich im selben Repository befinden müssen.

Die Verwendung einer festen Passphrase könnte theoretisch zu Brute-Force-Sicherheitslücken führen, wenn Angreifer Zugriff auf viele verschlüsselte Repos / Dateien haben. IMO ist die Wahrscheinlichkeit dafür sehr gering. In einem Hinweis am Ende dieses Tutorials wird erwähnt, dass die Verwendung einer festen Passphrase dazu führt, dass lokale Versionen eines Repos auf verschiedenen Computern immer anzeigen, dass Änderungen mit dem Status "Git" aufgetreten sind.

Heroku drängt auf die Verwendung von Umgebungsvariablen für Einstellungen und geheime Schlüssel:

Der traditionelle Ansatz für die Behandlung solcher Konfigurationsvariablen besteht darin, sie unter der Quelle abzulegen - in einer Eigenschaftendatei. Dies ist ein fehleranfälliger Prozess und besonders kompliziert für Open Source-Apps, die häufig separate (und private) Zweige mit app-spezifischen Konfigurationen unterhalten müssen.

Eine bessere Lösung besteht darin, Umgebungsvariablen zu verwenden und die Schlüssel aus dem Code herauszuhalten. Auf einem herkömmlichen Host oder bei lokaler Arbeit können Sie Umgebungsvariablen in Ihrem Bashrc festlegen. Auf Heroku verwenden Sie config vars.

Mit Foreman und .envDateien bietet Heroku eine beneidenswerte Toolchain zum Exportieren, Importieren und Synchronisieren von Umgebungsvariablen.

Persönlich halte ich es für falsch, geheime Schlüssel neben Code zu speichern. Es ist grundsätzlich nicht mit der Quellcodeverwaltung vereinbar, da die Schlüssel für Dienste bestimmt sind, die außerhalb des Codes liegen . Der einzige Segen wäre, dass ein Entwickler HEAD klonen und die Anwendung ohne Setup ausführen kann. Angenommen, ein Entwickler überprüft eine historische Überarbeitung des Codes. Ihre Kopie enthält das Datenbankkennwort des letzten Jahres, sodass die Anwendung für die heutige Datenbank fehlschlägt.

Mit der oben beschriebenen Heroku-Methode kann ein Entwickler die App des letzten Jahres auschecken, sie mit den heutigen Schlüsseln konfigurieren und sie erfolgreich für die heutige Datenbank ausführen.

Der sauberste Weg ist meiner Meinung nach die Verwendung von Umgebungsvariablen. Sie müssen sich beispielsweise nicht mit .dist- Dateien befassen , und der Projektstatus in der Produktionsumgebung entspricht dem Ihres lokalen Computers.

Ich empfehle , das Konfigurationskapitel der Twelve-Factor App zu lesen , die anderen auch, wenn Sie interessiert sind.

Eine Option wäre, projektgebundene Anmeldeinformationen in einen verschlüsselten Container (TrueCrypt oder Keepass) zu legen und ihn zu pushen.

Update als Antwort aus meinem Kommentar unten:

Interessante Frage übrigens. Ich habe gerade Folgendes gefunden: github.com/shadowhand/git-encrypt, das für die automatische Verschlüsselung sehr vielversprechend aussieht

Ich schlage vor, dafür Konfigurationsdateien zu verwenden und diese nicht zu versionieren.

Sie können jedoch Versionsbeispiele der Dateien.

Ich sehe kein Problem beim Teilen von Entwicklungseinstellungen. Per Definition sollte es keine wertvollen Daten enthalten.

BlackBox wurde kürzlich von StackExchange veröffentlicht und obwohl ich es noch nicht verwendet habe, scheint es die Probleme genau anzugehen und die in dieser Frage angeforderten Funktionen zu unterstützen.

Aus der Beschreibung unter https://github.com/StackExchange/blackbox :

Speichern Sie Geheimnisse sicher in einem VCS-Repo (z. B. Git oder Mercurial). Diese Befehle erleichtern Ihnen das GPG-Verschlüsseln bestimmter Dateien in einem Repo, sodass sie in Ihrem Repository "in Ruhe verschlüsselt" werden. Mit den Skripten können Sie sie jedoch leicht entschlüsseln, wenn Sie sie anzeigen oder bearbeiten müssen, und sie für die Verwendung in der Produktion entschlüsseln.

Seit ich diese Frage gestellt habe, habe ich mich für eine Lösung entschieden, die ich bei der Entwicklung kleiner Anwendungen mit einem kleinen Team von Mitarbeitern verwende.

Git-Krypta

git-crypt verwendet GPG, um Dateien transparent zu verschlüsseln, wenn ihre Namen mit bestimmten Mustern übereinstimmen. Aus Gründen der Intance, wenn Sie Ihrer .gitattributesDatei hinzufügen ...

*.secret.* filter=git-crypt diff=git-crypt

... dann wird eine Datei wie config.secret.jsonimmer mit Verschlüsselung auf Remote-Repos übertragen, bleibt jedoch auf Ihrem lokalen Dateisystem unverschlüsselt.

Wenn ich Ihrem Repo einen neuen GPG-Schlüssel (eine Person) hinzufügen möchte, der die geschützten Dateien entschlüsseln kann, führen Sie ihn aus git-crypt add-gpg-user <gpg_user_key>. Dadurch wird ein neues Commit erstellt. Der neue Benutzer kann nachfolgende Commits entschlüsseln.

Ich stelle die Frage allgemein, aber in meinem speziellen Fall möchte ich geheime Schlüssel und Passwörter für eine Django / Python-Site mit git und github speichern.

Nein, tu es einfach nicht, auch wenn es dein privates Repo ist und du nie vorhast, es zu teilen, tu es nicht.

Sie sollten eine local_settings.py erstellen, diese auf VCS ignorieren und in Ihrer settings.py so etwas tun

from local_settings import DATABASES, SECRET_KEY
DATABASES = DATABASES

SECRET_KEY = SECRET_KEY

Wenn Ihre Geheimhaltungseinstellungen so vielseitig sind, kann ich Ihnen gerne sagen, dass Sie etwas falsch machen

BEARBEITEN: Ich gehe davon aus, dass Sie Ihre vorherigen Kennwortversionen verfolgen möchten - beispielsweise für ein Skript, das die Wiederverwendung von Kennwörtern usw. verhindert.

Ich denke, GnuPG ist der beste Weg - es wird bereits in einem git-bezogenen Projekt (git-annex) verwendet, um in Cloud-Diensten gespeicherte Repository-Inhalte zu verschlüsseln. GnuPG (gnu pgp) bietet eine sehr starke schlüsselbasierte Verschlüsselung.

1. Sie behalten einen Schlüssel auf Ihrem lokalen Computer.
2. Sie fügen ignorierten Dateien 'mypassword' hinzu.
3. Beim Pre-Commit-Hook verschlüsseln Sie die mypassword-Datei in die von git verfolgte mypassword.gpg-Datei und fügen sie dem Commit hinzu.
4. Beim Post-Merge-Hook entschlüsseln Sie einfach mypassword.gpg in mypassword.

Wenn sich Ihre 'mypassword'-Datei nicht geändert hat, führt die Verschlüsselung zu demselben Chiffretext und wird nicht zum Index hinzugefügt (keine Redundanz). Die geringste Änderung von mypassword führt zu radikal unterschiedlichen Chiffretexten und mypassword.gpg im Staging-Bereich unterscheidet sich stark von denen im Repository und wird daher dem Commit hinzugefügt. Selbst wenn der Angreifer Ihren GPG-Schlüssel in die Hand nimmt, muss er das Passwort brutal erzwingen. Wenn der Angreifer mit Chiffretext Zugriff auf das Remote-Repository erhält, kann er eine Reihe von Chiffretexten vergleichen, deren Anzahl jedoch nicht ausreicht, um ihm einen nicht zu vernachlässigenden Vorteil zu verschaffen.

Später können Sie .gitattributes verwenden, um eine sofortige Entschlüsselung für das Beenden von git diff Ihres Passworts bereitzustellen.

Sie können auch separate Schlüssel für verschiedene Arten von Passwörtern usw. haben.

Normalerweise trenne ich das Passwort als Konfigurationsdatei. und machen sie dist.

/yourapp
    main.py
    default.cfg.dist

Und wenn ich laufe main.py, gib das echte Passwort eindefault.cfg das kopierte.

ps. wenn du mit git oder hg arbeitest. Sie können zu *.cfgerstellende Dateien ignorieren .gitignoreoder.hgignore

Geben Sie eine Möglichkeit an, die Konfiguration zu überschreiben

Dies ist der beste Weg, um eine Reihe vernünftiger Standardeinstellungen für die von Ihnen eingecheckte Konfiguration zu verwalten, ohne dass die Konfiguration vollständig sein muss oder Dinge wie Hostnamen und Anmeldeinformationen enthalten muss. Es gibt verschiedene Möglichkeiten, Standardkonfigurationen zu überschreiben.

Umgebungsvariablen (wie bereits erwähnt) sind eine Möglichkeit, dies zu tun.

Am besten suchen Sie nach einer externen Konfigurationsdatei, die die Standardkonfigurationswerte überschreibt. Auf diese Weise können Sie die externen Konfigurationen über ein Konfigurationsverwaltungssystem wie Chef, Puppet oder Cfengine verwalten. Die Konfigurationsverwaltung ist die Standardantwort für die Verwaltung von Konfigurationen, die von der Codebasis getrennt sind, sodass Sie keine Version ausführen müssen, um die Konfiguration auf einem einzelnen Host oder einer Gruppe von Hosts zu aktualisieren.

Zu Ihrer Information : Das Verschlüsseln von Creds ist nicht immer eine bewährte Methode, insbesondere an Orten mit begrenzten Ressourcen. Es kann vorkommen, dass Sie durch das Verschlüsseln von Creds keine zusätzliche Risikominderung erzielen und lediglich eine unnötige Komplexitätsebene hinzufügen. Stellen Sie sicher, dass Sie die richtige Analyse durchführen, bevor Sie eine Entscheidung treffen.

Verschlüsseln Sie die Kennwortdatei mit beispielsweise GPG. Fügen Sie die Schlüssel auf Ihrem lokalen Computer und auf Ihrem Server hinzu. Entschlüsseln Sie die Datei und legen Sie sie außerhalb Ihrer Repo-Ordner ab.

Ich verwende eine passwords.conf, die sich in meinem Homefolder befindet. Bei jeder Bereitstellung wird diese Datei aktualisiert.

Nein, private Schlüssel und Passwörter fallen nicht unter die Revisionskontrolle. Es gibt keinen Grund, alle Personen mit Lesezugriff auf Ihr Repository mit der Kenntnis vertraulicher Dienstanmeldeinformationen zu belasten, die in der Produktion verwendet werden, wenn höchstwahrscheinlich nicht alle Zugriff auf diese Dienste haben sollten.

Ab Django 1.4 werden Ihre Django-Projekte jetzt mit einem project.wsgiModul ausgeliefert, das das applicationObjekt definiert. Dies ist der perfekte Ort, um die Verwendung von a durchzusetzenproject.local Einstellungsmoduls standortspezifische Konfigurationen enthält.

Dieses Einstellungsmodul wird von der Revisionskontrolle ignoriert, ist jedoch erforderlich, wenn Sie Ihre Projektinstanz als WSGI-Anwendung ausführen, wie es für Produktionsumgebungen typisch ist. So sollte es aussehen:

import os

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project.local")

# This application object is used by the development server
# as well as any WSGI server configured to use this file.
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

Jetzt können Sie eine haben local.py Modul einrichten, dessen Eigentümer und Gruppe so konfiguriert werden kann, dass nur autorisiertes Personal und die Django-Prozesse den Inhalt der Datei lesen können.

Wenn Sie VCS für Ihre Geheimnisse benötigen, sollten Sie diese mindestens in einem zweiten Repository aufbewahren, das von Ihrem tatsächlichen Code getrennt ist. So können Sie Ihren Teammitgliedern Zugriff auf das Quellcode-Repository gewähren, ohne dass Ihre Anmeldeinformationen angezeigt werden. Hosten Sie dieses Repository außerdem an einem anderen Ort (z. B. auf Ihrem eigenen Server mit einem verschlüsselten Dateisystem, nicht auf Github), und zum Auschecken in das Produktionssystem können Sie so etwas wie ein Git-Submodul verwenden .

Ein anderer Ansatz könnte darin bestehen, das Speichern von Geheimnissen in Versionskontrollsystemen vollständig zu vermeiden und stattdessen ein Tool wie Vault von Hashicorp , einen geheimen Speicher mit Schlüsselrollen und -überwachung , mit einer API und eingebetteter Verschlüsselung, zu verwenden.

Das ist was ich mache:

• Bewahren Sie alle Geheimnisse als env vars in $ HOME / .secrets (go-r perms) auf, die $ HOME / .bashrc enthält (auf diese Weise werden die Geheimnisse nicht angezeigt, wenn Sie .bashrc vor jemandem öffnen).
• Konfigurationsdateien werden in VCS als Vorlagen gespeichert, z. B. config.properties, die als config.properties.tmpl gespeichert sind

• Die Vorlagendateien enthalten einen Platzhalter für das Geheimnis, z.

  my.password = ## MY_PASSWORD ##

• Bei der Anwendungsbereitstellung wird ein Skript ausgeführt, das die Vorlagendatei in die Zieldatei umwandelt und Platzhalter durch Werte von Umgebungsvariablen ersetzt, z. B. das Ändern von ## MY_PASSWORD ## in den Wert von $ MY_PASSWORD.

Sie können EncFS verwenden, wenn Ihr System dies bereitstellt. Auf diese Weise können Sie Ihre verschlüsselten Daten als Unterordner Ihres Repositorys behalten und Ihrer Anwendung gleichzeitig eine entschlüsselte Ansicht der bereitgestellten Daten bereitstellen. Da die Verschlüsselung transparent ist, sind beim Ziehen oder Drücken keine speziellen Vorgänge erforderlich.

Es müsste jedoch die EncFS-Ordner bereitstellen, was von Ihrer Anwendung basierend auf einem Kennwort durchgeführt werden könnte, das an einer anderen Stelle außerhalb der versionierten Ordner gespeichert ist (z. B. Umgebungsvariablen).