Comment gérer en toute sécurité des secrets avec HashiCorp Vault sur Ubuntu 16.04

introduction

Vault est un outil à code source ouvert qui fournit un moyen sûr et fiable de stocker et de distribuer des secrets tels que des clés d’API, des jetons d’accès et des mots de passe. Des logiciels tels que Vault peuvent revêtir une importance cruciale lors du déploiement d’applications nécessitant l’utilisation de données confidentielles ou sensibles.

Dans ce tutoriel, vous allez:

  • Installer Vault et le configurer en tant que service système

  • Initialiser un magasin de données crypté sur disque

  • Stockez et récupérez une valeur sensible en toute sécurité sur TLS

Avec certaines stratégies supplémentaires en place, vous pourrez utiliser Vault pour gérer de manière sécurisée les données sensibles de vos diverses applications et outils.

Comme pour tout service qui gère des informations sensibles, envisagez de lire une documentation supplémentaire sur les meilleures pratiques de déploiement de Vault avant de l’utiliser dans un environnement de type production. Par exemple, https://www.vaultproject.io/guides/production.html [Guide de renforcement de la production de Vault] traite de sujets tels que les stratégies, les jetons racine et l’audit.

Conditions préalables

Avant de commencer ce guide, vous aurez besoin des éléments suivants:

Étape 1 - Installation de Vault

HashiCorp fournit Vault sous forme de fichier binaire unique. Nous allons donc télécharger et installer manuellement l’exécutable de Vault.

Tout d’abord, téléchargez l’archive zip compressée de Vault pour Linux 64 bits. Vous pouvez trouver le lien vers la dernière version (0.9.5 au moment de la rédaction) sur Vault page de téléchargements.

wget https://releases.hashicorp.com/vault//vault__linux_amd64.zip

Ensuite, téléchargez la somme de contrôle pour ce fichier afin de pouvoir vérifier le téléchargement.

wget https://releases.hashicorp.com/vault//vault__SHA256SUMS

Ensuite, vérifiez l’intégrité de l’archive zip. Ceci confirme que le contenu de l’archive zip correspond à ce que Hashicorp a publié dans la version 0.9.5 de Vault.

grep linux_amd64 vault_*_SHA256SUMS | sha256sum -c -

Chaque ligne du fichier + SHA256SUMS + a une somme de contrôle et un nom de fichier, un pour chaque archive zip fournie par HashiCorp. La partie + grep + de la commande ci-dessus imprime la ligne avec la somme de contrôle et le nom du fichier binaire Linux 64 bits, puis redirige (+ | +) cette ligne vers la commande suivante. La commande SHA-256 vérifie, + -c +, que le fichier portant le nom de fichier de cette ligne correspond à la somme de contrôle de cette ligne.

L’exécution de la commande devrait indiquer que l’archive est + OK +. Sinon, essayez de télécharger à nouveau le fichier.

Outputvault__linux_amd64.zip:

Une fois la vérification de la somme de contrôle terminée, installez la commande + unzip + afin de pouvoir décompresser l’archive. Assurez-vous que votre référentiel de paquets est à jour en premier.

sudo apt-get update
sudo apt-get install unzip

Décompressez ensuite le fichier binaire Vault dans le répertoire de travail.

unzip vault_*.zip
OutputArchive:  vault__linux_amd64.zip
 inflating: vault

Déplacez l’exécutable de Vault dans un répertoire du système + PATH + du système pour le rendre accessible à partir de votre shell.

sudo cp vault /usr/local/bin/

Enfin, définissez un indicateur de capacité Linux sur le binaire. Ceci ajoute une sécurité supplémentaire en laissant le binaire effectuer le verrouillage de la mémoire sans élever inutilement ses privilèges.

sudo setcap cap_ipc_lock=+ep /usr/local/bin/vault

Vous pouvez maintenant utiliser la commande + vault +. Essayez de vérifier la version de Vault pour vous assurer que cela fonctionne.

vault --version
OutputVault v0.7.2 ('d28dd5a018294562dbc9a18c95554d52b5d12390')

L’exécutable Vault étant installé sur votre serveur, l’étape suivante consiste à le configurer pour qu’il s’exécute en tant que service système.

Étape 2 - Création du fichier de l’unité Vault

Systemd est le système d’initialisation Ubuntu qui, entre autres, gère les services du système. Pour configurer Vault en tant que service système, nous devons définir les éléments suivants:

  • Un utilisateur système pour que le démon Vault s’exécute en tant que

  • Un répertoire de données pour stocker les informations de Vault

  • Fichier de configuration de Vault

  • Le fichier + systemd + unit lui-même.

Tout d’abord, créez un utilisateur système * vault *.

sudo useradd -r -d /var/lib/vault -s /bin/nologin vault

Ici, nous utilisons + / var / lib / vault + comme répertoire personnel de l’utilisateur. Ceci sera utilisé comme répertoire de données Vault. Nous avons également défini le shell sur + / bin / nologin + pour restreindre l’utilisateur en tant que compte système non interactif.

Définissez la propriété de + / var / lib / vault + uniquement sur l’utilisateur * vault * et sur le groupe * vault *.

sudo install -o vault -g vault -m 750 -d /var/lib/vault

Maintenant, configurons le fichier de configuration de Vault, + / etc / vault.hcl +. Vous allez l’utiliser pour contrôler diverses options dans Vault, telles que l’emplacement de stockage des secrets cryptés.

Créez + vault.hcl + en utilisant + nano + ou votre éditeur de texte préféré.

sudo nano /etc/vault.hcl

Collez le texte suivant dans le fichier et assurez-vous de le remplacer par votre propre nom de domaine:

/etc/vault.hcl

backend "file" {
       path = "/var/lib/vault"
}

listener "tcp" {
       tls_disable = 0
       tls_cert_file = "/etc/letsencrypt/live//fullchain.pem"
       tls_key_file = "/etc/letsencrypt/live//privkey.pem"

}

Ce fichier de configuration indique à Vault de stocker les secrets chiffrés dans + / var / lib / vault + sur le disque et indique que Vault doit écouter les connexions via HTTPS à l’aide de certificats générés à partir du didacticiel Let’s Encrypt.

Enregistrez et fermez le fichier, puis sécurisez les autorisations du fichier de configuration Vault en permettant uniquement à l’utilisateur * vault * de le lire.

sudo chown vault:vault /etc/vault.hcl
sudo chmod 640 /etc/vault.hcl

Ensuite, pour laisser Systemd gérer le démon Vault persistant, créez un fichier unun à `+ ​​/ etc / systemd / system / vault.service + `.

sudo nano /etc/systemd/system/vault.service

Copiez et collez le texte suivant dans le fichier. Cela permet à Vault de s’exécuter en arrière-plan en tant que démon de service système persistant.

/etc/systemd/system/vault.service

[Unit]
Description=a tool for managing secrets
Documentation=https://vaultproject.io/docs/
After=network.target
ConditionFileNotEmpty=/etc/vault.hcl

[Service]
User=vault
Group=vault
ExecStart=/usr/local/bin/vault server -config=/etc/vault.hcl
ExecReload=/usr/local/bin/kill --signal HUP $MAINPID
CapabilityBoundingSet=CAP_SYSLOG CAP_IPC_LOCK
Capabilities=CAP_IPC_LOCK+ep
SecureBits=keep-caps
NoNewPrivileges=yes
KillSignal=SIGINT

[Install]
WantedBy=multi-user.target

La liste complète des options d’unité de service est longue, mais les options de configuration les plus importantes à noter dans la définition ci-dessus incluent:

  • + ConditionFileNotEmpty + garantit que le fichier de configuration + / etc / vault.hcl + existe.

  • + User et` + Group`, qui contrôlent les autorisations utilisateur avec lesquelles le démon Vault s’exécutera.

  • + ExecStart +, qui pointe sur l’exécutable que nous avons précédemment installé et définit les éléments à utiliser pour exécuter le service.

  • + ExecReload +, appelé lorsque Vault recharge son fichier de configuration, par exemple, lorsqu’il exécute + systemctl reload vault +.

  • + [Install] +, qui nous permet d’exécuter ce service de manière persistante au démarrage, de sorte que nous n’avons pas besoin de le démarrer manuellement après les redémarrages.

Enfin, Vault a besoin d’une autorisation pour lire les certificats que vous avez créés avec Certbot. Par défaut, ces certificats et clés privées ne sont accessibles que par * root *. Pour les rendre disponibles en toute sécurité, nous allons créer un groupe spécial appelé * pki * pour accéder à ces fichiers. Nous allons créer le groupe puis y ajouter l’utilisateur * vault *.

Enregistrez et fermez le fichier, puis créez le groupe * pki *.

sudo groupadd pki

Mettez à jour les autorisations sur les deux répertoires du répertoire + / etc / letsencrypt + pour permettre au groupe * pki * de lire le contenu.

sudo chgrp pki /etc/letsencrypt/{archive,live}
sudo chmod g+rx /etc/letsencrypt/{archive,live}

Ajoutez ensuite l’utilisateur * vault * au groupe * pki *. Cela permettra à Vault d’accéder aux certificats afin qu’il puisse répondre aux demandes de manière sécurisée via HTTPS.

sudo gpasswd -a vault pki

Enfin, pour plus de commodité, ajoutez une règle dans + / etc / hosts + pour diriger les demandes de Vault vers + localhost +.

Par défaut, Vault écoute uniquement les demandes de l’interface de bouclage (+ lo + ou l’adresse + 127.0.0.1 +). Cela permet de s’assurer que le service n’est pas exposé à l’internet public avant qu’il ne soit correctement sécurisé. Vous pourrez le mettre à jour plus tard, mais pour l’instant, ce changement de configuration nous permettra d’utiliser la commande + vault + et de résoudre correctement le nom de domaine sécurisé par HTTPS.

Remplacez ++ dans la commande suivante par le domaine pour lequel vous avez acquis le certificat Let’s Encrypt:

echo 127.0.0.1  | sudo tee -a /etc/hosts

Ceci ajoute la ligne +127.0.0.1 + à + ​​/ etc / hosts + afin que toutes les requêtes HTTP à ++ soient routées vers + localhost +.

Une fois l’exécutable Vault configuré, le fichier de service écrit et le fichier de configuration Vault terminé, nous sommes maintenant prêts à démarrer Vault et à initialiser le stockage secret.

Étape 3 - Initialisation du coffre-fort

Lorsque vous démarrez Vault pour la première fois, il ne sera pas initialisé, ce qui signifie qu’il n’est pas prêt à récupérer et à stocker des données.

La première fois que vous démarrez Vault, le backend qui stocke les secrets cryptés est également non initialisé. Démarrez le service système Vault pour initialiser le serveur et démarrez Vault lui-même.

sudo systemctl start vault

Vous pouvez effectuer une vérification rapide pour confirmer que le service a démarré avec succès.

sudo systemctl status vault

La sortie de cette commande doit inclure plusieurs informations sur le service en cours d’exécution, telles que son ID de processus et l’utilisation des ressources. Assurez-vous que la ligne suivante est incluse dans la sortie, ce qui indique que le service fonctionne correctement.

Output. . .
Active: active (running)
. . .

Si le service n’est pas actif, examinez les lignes de journal correspondantes à la fin de la sortie de la commande pour voir la sortie de Vault, ce qui peut vous aider à localiser tout problème.

Ensuite, nous allons définir une variable d’environnement pour indiquer à la commande + vault + comment se connecter au serveur Vault. Ici, Vault a été configuré pour écouter uniquement sur l’interface de bouclage local. Par conséquent, définissez la variable d’environnement + VAULT_ADDR + sur le point de terminaison HTTPS local.

export VAULT_ADDR=https://:8200

La commande + vault + peut maintenant communiquer avec le démon. Notez que la définition du nom d’hôte réel au lieu de simplement + localhost + ou + 127.0.0.1 + est nécessaire pour valider correctement le certificat HTTPS.

Confirmez que le coffre-fort est dans un état non initialisé en vérifiant son état.

vault status

Le serveur doit renvoyer une erreur 400 indiquant que le serveur n’est pas encore initialisé.

OutputError checking seal status: Error making API request.

URL: GET https://example.com:8200/v1/sys/seal-status
Code: 400. Errors:

* server is not yet initialized

Au moment de l’initialisation, Vault exposera deux informations qui ne seront pas disponibles à un autre moment:

  • * Jeton racine initial *. Cela équivaut aux autorisations root de votre déploiement Vault, ce qui permet la gestion de toutes les stratégies, montages, etc. de Vault.

  • * Décacheter les clés *. Celles-ci sont utilisées pour desserrer Vault au démarrage du démon, ce qui permet au démon Vault de décrypter le magasin de secrets du backend.

Plus précisément, le processus d’annulation de scellement de Vault déchiffre le backend à l’aide d’une clé formée par des partages de clé. C’est-à-dire que, lors de l’initialisation de Vault, vous pouvez choisir le nombre de clés d’annulation de scellement à créer et le nombre de clés nécessaires au moment du décachetage pour permettre de vider correctement le coffre-fort.

Une valeur simple et typique pour les paramètres d’annulation du scellement serait de créer trois clés et d’avoir besoin d’au moins deux de ces clés au moment du décachetage. Cela permet de séparer les partages de clés importants et de les stocker dans des emplacements distincts afin de garantir qu’un compromis n’est pas suffisant pour libérer le coffre-fort de Vault.

En d’autres termes, à chaque démarrage de Vault, il faudra au moins deux clés d’annulation du scellement afin de rendre le service disponible et prêt à être utilisé. Une fois scellés, les fichiers stockant les valeurs secrètes réelles resteront cryptés et inaccessibles.

Initialisez Vault avec les paramètres susmentionnés:

vault init -key-shares=3 -key-threshold=2

Enregistrez chaque jeton d’annulation de scellement et le jeton racine initial de manière sécurisée. Par exemple, une option serait de stocker une clé d’annulation dans un gestionnaire de mots de passe, une autre sur un lecteur USB et une autre dans un fichier crypté par GPG.

Vous pouvez maintenant décompresser Vault à l’aide des jetons d’annulation de scellement nouvellement créés. Commencez par décacheter en utilisant une clé.

vault operator unseal

La commande demandera un jeton d’annulation de scellement:

OutputKey (will be hidden):

Après l’avoir entrée, la sortie de la commande indiquera que l’annulation est en cours, mais nécessite encore une clé d’annulation avant que Vault soit prêt à être utilisé.

OutputSealed: true
Key Shares: 3
Key Threshold: 2
Unseal Progress: 1
Unseal Nonce: 3bdc838e-1b74-bc13-1d6f-c772f1694d83

Exécutez à nouveau la commande + unseal +.

vault operator unseal

Et entrez un autre jeton que celui que vous avez déjà utilisé:

OutputKey (will be hidden):

La sortie de la commande indique que le processus d’annulation et de scellement s’est terminé avec succès.

OutputSeal Type       shamir
Sealed          false
Total Shares    3
Threshold       2
Version         0.9.5
Cluster Name    vault-cluster-5511b3ff
Cluster ID      53522534-8ee1-8aec-86db-e13e4a499dd0
HA Enabled      false

Vault est maintenant être descellé et prêt à être utilisé. Ces étapes de décachetage sont nécessaires au démarrage ou au redémarrage de Vault.

Toutefois, la désanalyse est un processus distinct de l’interaction normale avec Vault (telle que la lecture et l’écriture de valeurs), qui sont authentifiées par tokens. Dans la dernière étape, nous allons créer les jetons d’accès et les règles nécessaires pour stocker les valeurs secrètes et lire / écrire sur des chemins spécifiques dans Vault.

Étape 4 - Lecture et écriture des secrets

Il existe plusieurs secret backends énumérés dans la documentation de Vault, mais pour cet exemple, nous utiliserons le https://www.vaultproject.io/docs/ secrets / generic / index.html [backend secret générique]. Ce backend stocke des paires clé / valeur simples dans Vault.

Commencez par enregistrer le jeton racine généré précédemment dans une variable shell pour en faciliter l’utilisation.

root_token=

Pour commencer, écrivez une valeur sur un chemin dans Vault.

VAULT_TOKEN=$root_token vault write secret/message value=mypassword

Dans cette commande, le préfixe + secret / + indique que nous écrivons dans le backend + generic + monté sur le chemin + secret + ', et nous stockons la clé + valeur + sur le chemin + message + ` avec la valeur + mypassword +. Nous avons utilisé le jeton racine, qui dispose des privilèges de superutilisateur, pour écrire le secret générique.

Dans un scénario réel, vous pouvez stocker des valeurs telles que des clés d’API ou des mots de passe pouvant être utilisés par des outils externes. Bien que vous puissiez lire à nouveau la valeur secrète à l’aide du jeton racine, il est utile de générer un jeton avec moins de privilèges avec des autorisations en lecture seule sur notre secret unique.

Créez un fichier nommé + policy.hcl +.

nano policy.hcl

Remplissez le fichier avec la stratégie Vault suivante, qui définit un accès en lecture seule au chemin secret de votre répertoire de travail:

policy.hcl

path "secret/message" {
    capabilities = ["read"]
}

Enregistrez et fermez le fichier, puis écrivez cette politique dans Vault. La commande suivante va créer une politique nommée + message-readonly + avec les droits de la politique.

VAULT_TOKEN=$root_token vault policy write message-readonly policy.hcl

Vous pouvez maintenant créer un jeton avec les droits spécifiés dans la stratégie.

VAULT_TOKEN=$root_token vault token create -policy="message-readonly"

La sortie ressemblera à ceci:

OutputKey             Value
---             -----
token
token_accessor  your_token_accessor
token_duration  768h0m0s
token_renewable true
token_policies  [default message-readonly]

Enregistrez la valeur + token dans une variable appelée` + id_token`.

app_token=

Vous pouvez utiliser la valeur + app_token + pour accéder aux données stockées dans le chemin + secret / message + (et aucune autre valeur dans Vault).

VAULT_TOKEN=$app_token vault read secret/message
OutputKey                     Value
---                     -----
refresh_interval        768h0m0s
value

Vous pouvez également vérifier que ce jeton sans privilège ne peut pas effectuer d’autres opérations, telles que la liste des secrets dans Vault.

VAULT_TOKEN=$app_token vault list secret/
OutputError reading secret/: Error making API request.

URL: GET https://example.com:8200/v1/secret?list=true
Code: 403. Errors:

*

Ceci vérifie que le jeton d’application moins privilégié ne peut effectuer aucune action destructive ou accéder à d’autres valeurs secrètes en dehors de celles explicitement spécifiées dans sa stratégie de centre de sauvegarde.

Conclusion

Dans cet article, vous avez installé, configuré et déployé Vault sur Ubuntu 16.04. Bien que ce didacticiel ne démontre que l’utilisation d’un jeton sans privilège, la documentation de Vault contient des informations supplémentaires sur les outils supplémentaires de stockage et d’accès aux secrets, ainsi que https: //www.vaultproject.io/docs/auth/index.htm[autres méthodes d’authentification].

Ces instructions expliquent comment déployer et utiliser Vault de manière assez basique. Assurez-vous donc de lire la documentation Vault et apportez les modifications de configuration appropriées à vos besoins. Certains changements prêts pour la production incluent:

  • Générer des jetons moins privilégiés pour un usage quotidien. Les stratégies spécifiques que ces jetons doivent utiliser dépendent du cas d’utilisation spécifique, mais le précédent + app_token + illustre la manière dont des jetons et des stratégies à privilèges limités peuvent être créés.

  • Si Vault est déployé dans le cadre d’un service d’équipe, l’initialisation de Vault avec des clés d’annulation de scellage pour chaque membre de l’équipe permet de s’assurer que le stockage de Vault n’est déchiffré que lorsque plusieurs membres de l’équipe participent au processus.