Stratégie pour garder les informations secrètes telles que les clés API en dehors du contrôle de source?

Je travaille sur un site Web qui permettra aux utilisateurs de se connecter en utilisant des informations d'identification OAuth telles que Twitter, Google, etc. Pour ce faire, je dois m'inscrire auprès de ces différents fournisseurs et obtenir une clé API super secrète que j'ai. protéger avec des gages contre diverses parties du corps. Si ma clé est gankée, la pièce est tirée.

La clé d'API doit voyager avec ma source, car elle est utilisée au moment de l'exécution pour exécuter les demandes d'authentification. Dans mon cas, la clé doit exister dans l'application dans un fichier de configuration ou dans le code lui-même. Ce n'est pas un problème lorsque je construis et publie à partir d'une seule machine. Cependant, lorsque nous intégrons le contrôle de source dans le mix, les choses se compliquent.

Comme je suis un bâtard pas cher, je préférerais de beaucoup utiliser des services de contrôle de source gratuits tels que TFS dans le cloud ou GitHub. Cela me laisse avec une légère énigme:

Comment conserver mon corps intact lorsque mes clés d'API sont dans mon code et que mon code est disponible dans un référentiel public?

Je peux penser à un certain nombre de façons de gérer cela, mais aucune d’elles n’est aussi satisfaisante.

• Je pourrais supprimer toutes les informations privées du code et les rééditer après le déploiement. Ce serait une douleur sévère à mettre en œuvre (je ne détaillerai pas les nombreuses manières), et n'est pas une option.
• Je pourrais le chiffrer. Mais comme je dois le déchiffrer, n'importe qui avec la source pourrait comprendre comment le faire. Inutile.
• Je pourrais payer pour le contrôle de source privé. LOL j / k dépenser de l'argent? S'il vous plaît.
• Je pourrais utiliser les fonctionnalités du langage pour séparer les informations sensibles du reste de ma source et donc les garder du contrôle de code source. C’est ce que je suis en train de faire à présent, mais cela pourrait facilement être gâché en vérifiant par erreur le fichier secret.

Je suis vraiment à la recherche d'un moyen sûr de ne pas partager mes données privées avec le monde entier (sauf sur Snapchat), qui fonctionnera sans heurts pendant le développement, le débogage et le déploiement, et sera également infaillible. C'est complètement irréaliste. Alors, que puis-je faire de manière réaliste?

_{Détails techniques: VS2012, C # 4.5, le contrôle de source sera soit un service TF, soit GitHub. Nous utilisons actuellement une classe partielle pour scinder les clés sensibles dans un fichier .cs séparé qui ne sera pas ajouté au contrôle de source. Je pense que GitHub pourrait avoir l’avantage de pouvoir utiliser .gitignore pour s’assurer que les fichiers de classe partiels ne sont pas archivés, mais j’ai tout gâché. J'espère un "oh, problème commun, voici comment vous le faites" mais je pourrais devoir me contenter de "cela ne craint pas autant qu'il aurait pu",: /}

Ne mettez pas vos informations secrètes dans votre code. Placez-le dans un fichier de configuration qui est lu par votre code au démarrage. Les fichiers de configuration ne doivent pas être placés sur le contrôle de version, sauf s’ils sont définis par défaut, et ils ne devraient pas avoir d’informations privées.

Voir aussi la question Contrôle de version et fichier de configuration personnelle pour savoir comment le faire.

Vous pouvez mettre toutes les clés privées / protégées en tant que variables d'environnement système. Votre fichier de configuration ressemblera à ceci:

private.key=#{systemEnvironment['PRIVATE_KEY']}

Voici comment nous traitons ces cas et rien ne va dans le code. Cela fonctionne très bien combiné avec différents fichiers de propriétés et profils. Nous utilisons différents fichiers de propriétés pour différents environnements. Dans notre environnement de développement local, nous plaçons les clés de développement dans les fichiers de propriétés pour simplifier la configuration locale:

private.key=A_DEVELOPMENT_LONG_KEY

Façon pure git

• .gitignore fichier inclus avec données privées
• Utilisez une branche locale dans laquelle vous remplacez TEMPLATEparDATA
• Utilisez des filtres de nettoyage / nettoyage, dans lesquels le script du filtre (local) effectue le remplacement bidirectionnel TEMPLATE<->DATA

Chemin mercurial

• Patch (s) MQ au-dessus du code factice, qui remplace TEMPLATEpar DATA(les ensembles de modifications sont publics, le patch est privé)
• Extension de mot clé avec des mots clés spécialement conçus (développés uniquement dans votre répertoire de travail )

SCM-manière agnostique

• Remplacer les mots-clés dans le cadre du processus de création / déploiement

Je mets des secrets dans des fichiers cryptés que je valide ensuite. La phrase secrète est fournie au démarrage du système ou est stockée dans un petit fichier que je ne valide pas. C'est bien qu'Emacs gère avec joie ces fichiers cryptés. Par exemple, le fichier init emacs inclut: (chargez "secrets.el.gpg"), ce qui fonctionne - en me demandant le mot de passe pour ces rares occurrences lorsque je lance l'éditeur. Je ne m'inquiète pas que quelqu'un casse le cryptage.

Ceci est très spécifique à Android / Gradle mais vous pouvez définir les clés dans votre gradle.propertiesfichier global situé dans user home/.gradle/. Cela est également utile car vous pouvez utiliser différentes propriétés en fonction de buildType ou de la saveur, c'est-à-dire une API pour dev et une autre pour la version.

gradle.properties

MY_PRIVATE_API_KEY=12356abcefg

build.gradle

buildTypes {
        debug{
            buildConfigField("String", "GOOGLE_VERIFICATION_API_KEY", "\"" + MY_PRIVATE_API_KEY +"\"")
            minifyEnabled false
            applicationIdSuffix ".debug"
            }
        }

Dans le code que vous référencez comme ceci

String myAPI = BuildConfig.GOOGLE_VERIFICATION_API_KEY;

Vous n'êtes pas censé distribuer cette clé avec votre application ou la stocker dans le référentiel de code source. Cette question demande comment faire cela, et ce n'est pas ce qui se fait normalement.

Application Web mobile

Pour Android / iPhone, l'appareil doit demander la clé à votre propre service Web lors de la première exécution de l'application. La clé est ensuite stockée dans un endroit sûr. La clé doit-elle être modifiée ou révoquée par l'éditeur? Votre service Web peut publier une nouvelle clé.

Application Web hébergée

Les clients utilisant une licence de votre logiciel devront saisir manuellement la clé lors de la première configuration du logiciel. Vous pouvez donner à chacun la même clé, des clés différentes ou obtenir la leur.

Code source publié

Vous stockez votre code source dans un référentiel public, mais pas la clé. Dans la configuration du fichier, vous ajoutez les lignes * place key ici * . Lorsqu'un développeur utilise votre code source, il en fait une copie sample.cfget ajoute sa propre clé.

Vous ne conservez pas votre config.cfgfichier utilisé pour le développement ou la production dans le référentiel.

Utilisez des variables d’environnement pour les éléments secrets qui changent pour chaque serveur.

http://en.wikipedia.org/wiki/Variable_Environnement

Leur utilisation dépend de la langue.

Je pense que c'est un problème avec lequel tout le monde a eu des problèmes à un moment donné.

Voici un flux de travail que j'ai utilisé, qui pourrait fonctionner pour vous. Il utilise .gitignore avec une torsion:

1. Tous les fichiers de configuration vont dans un dossier spécial (w / sample config files - optionnel)
2. Tous les fichiers de configuration sont inclus dans .gitignore, afin qu’ils ne deviennent pas publics
3. Configurez un serveur gitolite (ou votre serveur git préféré) sur une boîte privée
4. Ajouter un repo avec tous les fichiers de configuration du serveur privé
5. Ajouter un script pour copier les fichiers de configuration dans le dossier spécial du référentiel principal (facultatif)

Désormais, vous pouvez cloner le référentiel de configuration sur n’importe quel système de développement et de déploiement. Il suffit d’exécuter le script pour copier les fichiers dans le bon dossier et vous avez terminé.

Vous obtenez toujours tous les bonbons GitHub, partagez votre code avec le monde entier et les données sensibles ne sont jamais dans le référentiel principal, elles ne sont donc pas rendues publiques. Ils ne sont encore qu'une attraction et une copie de tout système de déploiement.

J'utilise une boîte de 15 $ / an pour le serveur git privé, mais vous pouvez également en configurer une à la maison, selon les exigences de la politique de la radicale ;-)

PS: Vous pouvez également utiliser un sous-module git ( http://git-scm.com/docs/git-submodule ), mais j'oublie toujours les commandes, règles donc rapides et sales!

Utilisez le chiffrement, mais fournissez une clé principale au démarrage, sous forme de mot de passe sur la console, dans un fichier que seul l'utilisateur du processus peut lire, ou à partir d'un magasin de clés fourni par le système, tel que le trousseau Mac OS ou le magasin de clés Windows.

Pour une livraison continue, vous aurez besoin de diverses clés enregistrées quelque part. La configuration doit être distinguée du code, mais il est judicieux de la garder sous contrôle de révision.

3 stratégies, non encore mentionnées (?)

À l'enregistrement ou dans un pré-enregistrement VCS

• rechercher des chaînes avec une entropie élevée, exemple- detect -secrets
• regex recherche des modèles de clés d'API bien connus. Les clés AKIA * d’AWS en sont un exemple, git-secrets est un outil basé sur cela. En outre, les noms de variables comme «mot de passe» avec une affectation constante.
• rechercher des secrets connus - vous connaissez vos secrets, recherchez un texte à leur sujet. Ou utilisez un outil, j'ai écrit cette preuve de concept .

Stratégies déjà mentionnées

• stocker dans un fichier en dehors de l'arbre source
• l'avoir dans l'arbre des sources, mais dire à VCS de l'ignorer
• les variables d'environnement sont une variante du stockage de données en dehors de l'arbre source
• il suffit de ne pas donner les secrets précieux aux développeurs

Conservez les informations privées en dehors de votre contrôle de source. Créez une valeur par défaut non chargée pour la distribution et faites en sorte que votre VCS ignore le vrai. Votre processus d'installation (qu'il soit manuel, configure / build ou assistant) doit gérer la création et le remplissage du nouveau fichier. Modifiez éventuellement les autorisations sur le fichier pour vous assurer que seul l'utilisateur requis (serveur Web?) Peut le lire.

Avantages:

• Ne suppose pas d'entité de développement == entité de production
• Ne présume pas que tous les collaborateurs / réviseurs de code sont dignes de confiance
• Évitez les erreurs faciles en le gardant hors du contrôle de version
• Facile à automatiser les installations avec une configuration personnalisée pour QA / builds

Si vous le faites déjà et que vous l'enregistrez accidentellement, ajoutez-le à celui de votre projet .gitignore. Cela rendra impossible de faire à nouveau.

Il existe de nombreux hôtes Git gratuits dans le monde qui fournissent des référentiels privés. Bien que vous ne devriez jamais mettre à jour vos informations d'identification, vous pouvez également bénéficier de solutions de stockage bon marché et de pensions privées. ^ _ ^

Au lieu d'avoir la clé OAuth stockée en tant que données brutes n'importe où, pourquoi ne pas exécuter la chaîne via un algorithme de cryptage et la stocker sous forme de hachage salé? Ensuite, utilisez un fichier de configuration pour le restaurer au moment de l'exécution. Ainsi, la clé n'est stockée nulle part, qu'elle soit stockée sur une boîte de développement ou sur le serveur lui-même.

Vous pouvez même créer une API de telle sorte que votre serveur génère automatiquement une nouvelle clé d'API salée et hachée, requête par requête. Ainsi, même votre équipe ne pourra pas voir la source OAuth.

Edit: essayez peut-être la bibliothèque de cryptographie Javascript de Stanford , elle permet un cryptage / décryptage symétrique plutôt sûr.