Quelle est la meilleure pratique pour gérer les mots de passe dans les dépôts git?

Une approche peut-être de définir le mot de passe (ou clé API) à l'aide d'une variable d'environnement.
Si ce mot de passe est hors de contrôle de révision.

Avec Bash, vous pouvez définir la variable d'environnement à l'aide de

export your_env_variable='your_password'

Cette approche peut être utilisée qu'avec l'intégration continue des services comme Travis, votre code (sans mot de passe) stockée dans un GitHub référentiel peut être exécuté par Travis (avec votre mot de passe étant définie à l'aide de la variable d'environnement).

Avec Bash, vous pouvez obtenir la valeur d'une variable d'environnement à l'aide de:

echo "$your_env_variable"

Avec Python, vous pouvez obtenir la valeur d'une variable d'environnement à l'aide de:

import os
print(os.environ['your_env_variable'])

PS: sachez que c'est probablement un peu risqué (mais c'est assez fréquent) https://www.bleepingcomputer.com/news/security/javascript-packages-caught-stealing-environment-variables/

PS2: ce dev.to article intitulé "Comment stocker de manière sécurisée les clés API" peut être intéressant à lire.

On peut utiliser Vault qui la fixe, les magasins, et les contrôles d'accès pour les jetons, les mots de passe, certificats, clés API, etc. Par exemple Ansible utilise le Ansible Voûte qui traite avec des mots de passe ou des certificats utilisés dans les tablettes playbook

Traiter avec des mots de passe dans les dépôts seraient traitées de différentes manières en fonction de votre problème.

1. Ne pas le faire.

Et les moyens d'éviter de faire sont couverts dans certaines réponses - .gitignore, config.exemple, etc

• .gitignore: Stocker sur les serveurs, etc, mais pas de Git (solution faible)
• Variables d'environnement: https://stackoverflow.com/a/30664318/3070485
• Config.exemple: https://stackoverflow.com/a/2397905/3070485
• Paramètre de ligne de commande: saisissez manuellement le mot de passe au démarrage du programme

ou 2. Faire référentiel accessible uniquement aux personnes autorisées

I. e. les gens qui sont autorisés à connaître le mot de passe. chmod et les groupes d'utilisateurs vient à l'esprit; aussi des problèmes comme le devrait Github ou AWS employés le droit de voir les choses si vous hébergez vos dépôts ou des serveurs de l'extérieur?

ou 3. Chiffrer les données sensibles (le but de cette réponse)

Si vous souhaitez stocker vos fichiers de configuration contenant des informations sensibles (comme les mots de passe) dans un lieu public, alors il doit être chiffré. Les fichiers peuvent être déchiffrées lorsqu'ils ont été récupérés à partir du référentiel, ou même utilisé directement à partir de leur forme cryptée.

Un exemple javascript solution à l'aide chiffrée des données de configuration est indiqué ci-dessous.

const fs = require('fs');
const NodeRSA = require('node-rsa');

let privatekey = new NodeRSA();
privatekey.importKey(fs.readFileSync('private.key', 'utf8'));
const config = privatekey.decrypt(fs.readFileSync('config.RSA', 'utf8'), 'json');

console.log('decrypted: ', config);

De sorte que vous pouvez récupérer une crypté fichier de configuration de l'écriture de quelques lignes de Javascript.

Noter que de mettre un fichier config.RSA dans un dépôt git aboutirait à rendre un fichier binaire et donc à perdre de nombreux avantages de quelque chose comme Git, par exemple, la capacité de cherry pick modifications.

La solution qui pourrait être pour chiffrer les paires clé-valeur ou peut-être juste valeurs. Vous pourriez crypter toutes les valeurs, par exemple si vous avez un fichier séparé pour les informations sensibles, ou chiffrer que les valeurs sensibles si vous avez toutes les valeurs dans un fichier. (voir ci-dessous)

Mon exemple ci-dessus est un peu inutile pour tous ceux qui veulent faire un essai avec elle, ou comme un exemple pour démarrer à partir, car elle suppose l'existence de clés RSA et crypté fichier de config config.RSA.

Alors, voici quelques lignes de code supplémentaires ajoutés pour créer des clés RSA et un fichier de config pour jouer avec.

const fs = require('fs');
const NodeRSA = require('node-rsa');

/////////////////////////////
// Generate some keys for testing
/////////////////////////////

const examplekey = new NodeRSA({b: 2048});

fs.writeFileSync('private.key', examplekey.exportKey('pkcs8-private'));
fs.writeFileSync('public.key', examplekey.exportKey('pkcs8-public'));

/////////////////////////////
// Do this on the Machine creating the config file
/////////////////////////////

const configToStore = {Goodbye: 'Cruel world'};

let publickey = new NodeRSA();
publickey.importKey(fs.readFileSync('public.key', 'utf8'));

fs.writeFileSync('config.RSA', publickey.encrypt(configToStore, 'base64'), 'utf8');

/////////////////////////////
// Do this on the Machine consuming the config file
/////////////////////////////

let privatekey = new NodeRSA();
privatekey.importKey(fs.readFileSync('private.key', 'utf8'));

const config = privatekey.decrypt(fs.readFileSync('config.RSA', 'utf8'), 'json');
console.log('decrypted: ', config);

Chiffrement uniquement les valeurs de

fs.writeFileSync('config.RSA', JSON.stringify(config,null,2), 'utf8');

Vous pouvez décrypter un fichier de configuration avec des valeurs chiffrées en utilisant quelque chose comme cela.

const savedconfig = JSON.parse(fs.readFileSync('config.RSA', 'utf8'));
let config = {...savedconfig};
Object.keys(savedconfig).forEach(key => {
    config[key] = privatekey.decrypt(savedconfig[key], 'utf8');
});

Avec chaque élément de configuration sur une ligne distincte (par exemple, Hello et Goodbye ci-dessus), Git reconnaîtra mieux ce qui se passe dans un fichier et enregistre les modifications apportées aux éléments d'information que les différences plutôt que les dossiers complets. Git sera également en mesure de gérer les fusions et les prélèvements cherry etc mieux.

Cependant, plus vous voulez de contrôle de version des modifications sensibles de l'information, plus vous vous déplacez vers un COFFRE-fort DÉPÔT de la solution de (2) et loin d'un CHIFFRÉS INFO (3) de la solution.

Faire confiance, mais vérifier.

Dans .gitignore cela permettrait d'exclure un "sécurisé", annuaire de l'opération:

secure/

Mais je partage @Michael Potter's de la paranoïa. Donc à vérifier .gitignore, voici un Python de test de l'unité que soulèverait un klaxon si cette "sécuriser" le répertoire n'est jamais vérifié. Et de cocher la case, une légitime répertoire est également testées:

def test_github_not_getting_credentials(self):
    safety_url = 'https://github.com/BobStein/fliki/tree/master/static'
    danger_url = 'https://github.com/BobStein/fliki/tree/master/secure'

    self.assertEqual(200, urllib.request.urlopen(safety_url).status)

    with self.assertRaises(urllib.error.HTTPError):
        urllib.request.urlopen(danger_url)