Comment puis-je enregistrer mes clés secrètes et mon mot de passe en toute sécurité dans mon système de contrôle de version?

Je garde des paramètres importants comme les noms d'hôte et les ports des serveurs de développement et de production dans mon système de contrôle de version. Mais je sais que c'est une mauvaise pratique de garder des secrets (comme les clés privées et les mots de passe de base de données) dans un référentiel VCS.

Mais les mots de passe - comme tout autre paramètre - semblent devoir être versionnés. Alors, quelle est la bonne façon de contrôler la version des mots de passe?

J'imagine que cela impliquerait de garder les secrets dans leur propre fichier de "paramètres secrets" et de faire chiffrer ce fichier et contrôler la version. Mais quelles technologies? Et comment faire cela correctement? Y a-t-il une meilleure façon de procéder?

Je pose la question en général, mais dans mon cas spécifique, je voudrais stocker des clés secrètes et des mots de passe pour un site Django / Python en utilisant git et github .

De plus, une solution idéale ferait quelque chose de magique lorsque je pousse / tire avec git - par exemple, si le fichier de mots de passe chiffrés change, un script est exécuté qui demande un mot de passe et le déchiffre en place.

Vous avez parfaitement raison de vouloir crypter votre fichier de paramètres sensibles tout en conservant le fichier dans le contrôle de version. Comme vous le mentionnez, la meilleure solution serait celle dans laquelle Git cryptera de manière transparente certains fichiers sensibles lorsque vous les poussez afin que localement (c'est-à-dire sur toute machine possédant votre certificat) vous puissiez utiliser le fichier de paramètres, mais Git ou Dropbox ou qui que ce soit le stockage de vos fichiers sous VC ne permet pas de lire les informations en texte brut.

Tutoriel sur le cryptage / décryptage transparent pendant Push / Pull

Cet essentiel https://gist.github.com/873637 montre un tutoriel sur la façon d'utiliser le pilote de filtre smudge / clean de Git avec openssl pour crypter de manière transparente les fichiers poussés. Il vous suffit de faire une configuration initiale.

Résumé de son fonctionnement

Vous allez essentiellement créer un .gitencryptdossier contenant 3 scripts bash,

clean_filter_openssl 
smudge_filter_openssl 
diff_filter_openssl 

qui sont utilisés par Git pour le déchiffrement, le chiffrement et la prise en charge de Git diff. Une phrase de passe principale et un salt (corrigé!) Sont définis dans ces scripts et vous DEVEZ vous assurer que .gitencrypt n'est jamais réellement poussé. Exemple de clean_filter_opensslscript:

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

Similaire pour smudge_filter_open_sslet diff_filter_oepnssl. Voir Gist.

Votre dépôt contenant des informations sensibles doit avoir un fichier .gitattribute (non chiffré et inclus dans le dépôt) qui fait référence au répertoire .gitencrypt (qui contient tout ce dont Git a besoin pour chiffrer / déchiffrer le projet de manière transparente) et qui est présent sur votre machine locale.

.gitattribute Contenu:

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

Enfin, vous devrez également ajouter le contenu suivant à votre .git/configfichier

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

Désormais, lorsque vous transférez le référentiel contenant vos informations sensibles vers un référentiel distant, les fichiers seront chiffrés de manière transparente. Lorsque vous effectuez une extraction à partir d'une machine locale qui a le répertoire .gitencrypt (contenant votre phrase de passe), les fichiers seront déchiffrés de manière transparente.

Remarques

Je dois noter que ce tutoriel ne décrit pas un moyen de chiffrer uniquement votre fichier de paramètres sensibles. Cela cryptera de manière transparente l'ensemble du référentiel qui est poussé vers l'hôte VC distant et décryptera l'intégralité du référentiel afin qu'il soit entièrement décrypté localement. Pour obtenir le comportement souhaité, vous pouvez placer des fichiers sensibles pour un ou plusieurs projets dans un sensitive_settings_repo. Vous pouvez étudier comment cette technique de chiffrement transparent fonctionne avec les sous-modules Git http://git-scm.com/book/en/Git-Tools-Submodules si vous avez vraiment besoin que les fichiers sensibles se trouvent dans le même référentiel.

L'utilisation d'une phrase secrète fixe pourrait théoriquement conduire à des vulnérabilités de force brute si les attaquants avaient accès à de nombreux dépôts / fichiers cryptés. OMI, la probabilité de cela est très faible. Comme une note au bas de ce tutoriel le mentionne, le fait de ne pas utiliser de phrase secrète fixe entraînera des versions locales d'un dépôt sur différentes machines montrant toujours que des modifications ont eu lieu avec 'git status'.

Heroku pousse l'utilisation de variables d'environnement pour les paramètres et les clés secrètes:

L'approche traditionnelle pour gérer ces variables de configuration est de les mettre sous source - dans un fichier de propriétés d'une sorte. Il s'agit d'un processus sujet aux erreurs, et est particulièrement compliqué pour les applications open source qui doivent souvent maintenir des branches séparées (et privées) avec des configurations spécifiques à l'application.

Une meilleure solution consiste à utiliser des variables d'environnement et à garder les clés hors du code. Sur un hôte traditionnel ou travaillant localement, vous pouvez définir des variables d'environnement dans votre bashrc. Sur Heroku, vous utilisez config vars.

Avec Foreman et les .envfichiers, Heroku fournit une chaîne d'outils enviable pour exporter, importer et synchroniser les variables d'environnement.

Personnellement, je pense qu'il est erroné de sauvegarder des clés secrètes à côté du code. C'est fondamentalement incompatible avec le contrôle de code source, car les clés sont pour des services extrinsèques au code . Le seul avantage serait qu'un développeur peut cloner HEAD et exécuter l'application sans aucune configuration. Cependant, supposons qu'un développeur vérifie une révision historique du code. Leur copie comprendra le mot de passe de la base de données de l'année dernière, de sorte que l'application échouera par rapport à la base de données d'aujourd'hui.

Avec la méthode Heroku ci-dessus, un développeur peut vérifier l'application de l'année dernière, la configurer avec les clés d'aujourd'hui et l'exécuter avec succès sur la base de données d'aujourd'hui.

Le moyen le plus propre à mon avis est d'utiliser des variables d'environnement. Vous n'aurez pas à gérer les fichiers .dist par exemple, et l'état du projet sur l'environnement de production serait le même que celui de votre machine locale.

Je recommande de lire le chapitre de configuration de l' application Twelve-Factor , les autres aussi si cela vous intéresse.

Une option serait de placer les informations d'identification liées au projet dans un conteneur chiffré (TrueCrypt ou Keepass) et de le pousser.

Mettre à jour comme réponse de mon commentaire ci-dessous:

Question intéressante btw. Je viens de trouver ceci: github.com/shadowhand/git-encrypt qui semble très prometteur pour le cryptage automatique

Je suggère d'utiliser des fichiers de configuration pour cela et de ne pas les versionner.

Vous pouvez cependant version des exemples des fichiers.

Je ne vois aucun problème de partage des paramètres de développement. Par définition, il ne doit contenir aucune donnée valable.

BlackBox a été récemment publié par StackExchange et même si je ne l'ai pas encore utilisé, il semble résoudre exactement les problèmes et prendre en charge les fonctionnalités demandées dans cette question.

D'après la description sur https://github.com/StackExchange/blackbox :

Stockez en toute sécurité les secrets dans un dépôt VCS (c'est-à-dire Git ou Mercurial). Ces commandes vous permettent de chiffrer facilement par GPG des fichiers spécifiques dans un référentiel afin qu'ils soient «chiffrés au repos» dans votre référentiel. Cependant, les scripts facilitent leur décryptage lorsque vous avez besoin de les afficher ou de les modifier, et de les décrypter pour une utilisation en production.

Depuis que j'ai posé cette question, j'ai opté pour une solution, que j'utilise lors du développement d'une petite application avec une petite équipe de personnes.

git-crypt

git-crypt utilise GPG pour crypter de manière transparente les fichiers lorsque leurs noms correspondent à certains modèles. Pour intance, si vous ajoutez à votre .gitattributesfichier ...

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

... alors un fichier comme config.secret.jsonsera toujours poussé vers des dépôts distants avec cryptage, mais restera non crypté sur votre système de fichiers local.

Si je veux ajouter une nouvelle clé GPG (une personne) à votre référentiel qui peut décrypter les fichiers protégés, exécutez-la git-crypt add-gpg-user <gpg_user_key>. Cela crée un nouveau commit. Le nouvel utilisateur pourra déchiffrer les commits suivants.

Je pose la question en général, mais dans mon cas spécifique, je voudrais stocker des clés secrètes et des mots de passe pour un site Django / Python en utilisant git et github.

Non, ne le faites pas, même s'il s'agit de votre dépôt privé et que vous n'avez jamais l'intention de le partager, ne le faites pas.

Vous devez créer un local_settings.py, le mettre sur VCS ignorer et dans votre settings.py faire quelque chose comme

from local_settings import DATABASES, SECRET_KEY
DATABASES = DATABASES

SECRET_KEY = SECRET_KEY

Si vos paramètres secrets sont aussi polyvalents, je suis impatient de dire que vous faites quelque chose de mal

EDIT: Je suppose que vous voulez garder une trace de vos versions précédentes de mots de passe - par exemple, pour un script qui empêcherait la réutilisation du mot de passe, etc.

Je pense que GnuPG est la meilleure solution - il est déjà utilisé dans un projet lié à git (git-annexe) pour crypter le contenu du référentiel stocké sur les services cloud. GnuPG (gnu pgp) fournit un cryptage à clé très puissant.

1. Vous gardez une clé sur votre machine locale.
2. Vous ajoutez «mypassword» aux fichiers ignorés.
3. Lors du hook pré-commit, vous cryptez le fichier mypassword dans le fichier mypassword.gpg suivi par git et ajoutez-le au commit.
4. Sur le hook post-fusion, vous décryptez simplement mypassword.gpg en mypassword.

Maintenant, si votre fichier 'mypassword' n'a pas changé, le chiffrement entraînera le même texte chiffré et il ne sera pas ajouté à l'index (pas de redondance). La moindre modification de mypassword entraîne un texte chiffré radicalement différent et mypassword.gpg dans la zone de préparation diffère beaucoup de celui du référentiel, donc sera ajouté au commit. Même si l'attaquant met la main sur votre clé gpg, il doit encore forcer brutalement le mot de passe. Si l'attaquant obtient un accès au référentiel distant avec du texte chiffré, il peut comparer un tas de textes chiffrés, mais leur nombre ne sera pas suffisant pour lui donner un avantage non négligeable.

Plus tard, vous pouvez utiliser .gitattributes pour fournir un décryptage à la volée pour quit git diff de votre mot de passe.

Vous pouvez également avoir des clés séparées pour différents types de mots de passe, etc.

Habituellement, je sépare le mot de passe dans un fichier de configuration. et faites-les dist.

/yourapp
    main.py
    default.cfg.dist

Et quand je cours main.py, mettez le vrai mot de passe dans default.cfgcelui copié.

ps. lorsque vous travaillez avec git ou hg. vous pouvez ignorer les *.cfgfichiers à créer .gitignoreou.hgignore

Fournir un moyen de remplacer la configuration

C'est la meilleure façon de gérer un ensemble de valeurs par défaut saines pour la configuration que vous archivez sans exiger que la configuration soit complète, ou contenir des éléments tels que les noms d'hôte et les informations d'identification. Il existe plusieurs façons de remplacer les configurations par défaut.

Les variables d'environnement (comme d'autres l'ont déjà mentionné) sont un moyen d'y parvenir.

Le meilleur moyen est de rechercher un fichier de configuration externe qui remplace les valeurs de configuration par défaut. Cela vous permet de gérer les configs externes via un système de gestion de configuration comme Chef, Puppet ou Cfengine. La gestion de la configuration est la réponse standard pour la gestion des configurations séparées de la base de code afin que vous n'ayez pas à faire une version pour mettre à jour la configuration sur un seul hôte ou un groupe d'hôtes.

Pour votre information: le chiffrement des crédits n'est pas toujours une bonne pratique, en particulier dans un endroit aux ressources limitées. Il se peut que le cryptage des creds ne vous apporte aucune atténuation des risques supplémentaire et ajoute simplement une couche de complexité inutile. Assurez-vous de faire l'analyse appropriée avant de prendre une décision.

Cryptez le fichier de mots de passe, en utilisant par exemple GPG. Ajoutez les clés sur votre machine locale et sur votre serveur. Décryptez le fichier et placez-le en dehors de vos dossiers de dépôt.

J'utilise un passwords.conf, situé dans mon dossier personnel. À chaque déploiement, ce fichier est mis à jour.

Non, les clés privées et les mots de passe ne relèvent pas du contrôle des révisions. Il n'y a aucune raison de charger tout le monde avec un accès en lecture à votre référentiel de connaître les informations d'identification de service sensibles utilisées en production, alors que très probablement, tous ne devraient pas avoir accès à ces services.

À partir de Django 1.4, vos projets Django sont désormais livrés avec un project.wsgimodule qui définit l' applicationobjet et c'est un endroit idéal pour commencer à appliquer l'utilisation d'un project.localmodule de paramètres qui contient des configurations spécifiques au site.

Ce module de paramètres est ignoré du contrôle de révision, mais sa présence est requise lors de l'exécution de votre instance de projet en tant qu'application WSGI, typique des environnements de production. Voici à quoi cela devrait ressembler:

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()

Vous pouvez maintenant avoir un local.pymodule dont le propriétaire et le groupe peuvent être configurés pour que seuls le personnel autorisé et les processus Django puissent lire le contenu du fichier.

Si vous avez besoin de VCS pour vos secrets, vous devez au moins les conserver dans un deuxième référentiel séparé de votre code réel. Ainsi, vous pouvez donner aux membres de votre équipe l'accès au référentiel de code source et ils ne verront pas vos informations d'identification. De plus, hébergez ce référentiel ailleurs (par exemple sur votre propre serveur avec un système de fichiers chiffré, pas sur github) et pour le vérifier sur le système de production, vous pouvez utiliser quelque chose comme git-submodule .

Une autre approche pourrait consister à éviter complètement de sauvegarder des secrets dans les systèmes de contrôle de version et à utiliser à la place un outil comme le coffre-fort de hashicorp , un stockage secret avec roulement et audit de clés, avec une API et un cryptage intégré.

C'est ce que je fais:

• Gardez tous les secrets en tant que vars env dans $ HOME / .secrets (go-r perms) que $ HOME / .bashrc sources (de cette façon, si vous ouvrez .bashrc devant quelqu'un, ils ne verront pas les secrets)
• Les fichiers de configuration sont stockés dans VCS en tant que modèles, tels que config.properties stockés sous config.properties.tmpl

• Les fichiers de modèle contiennent un espace réservé pour le secret, tel que:

  my.password = ## MY_PASSWORD ##

• Lors du déploiement de l'application, un script est exécuté qui transforme le fichier de modèle en fichier cible, en remplaçant les espaces réservés par des valeurs de variables d'environnement, comme la modification de ## MY_PASSWORD ## par la valeur de $ MY_PASSWORD.

Vous pouvez utiliser EncFS si votre système le fournit. Ainsi, vous pouvez conserver vos données cryptées en tant que sous-dossier de votre référentiel, tout en fournissant à votre application une vue décryptée des données montées de côté. Comme le cryptage est transparent, aucune opération spéciale n'est nécessaire sur pull ou push.

Il faudrait cependant monter les dossiers EncFS, ce qui pourrait être fait par votre application sur la base d'un mot de passe stocké ailleurs en dehors des dossiers versionnés (par exemple, les variables d'environnement).