• Site officiel de Vault
• How To Securely Manage Secrets with HashiCorp Vault on Ubuntu 16.04

1. Télécharger le fichier Vault requis selon le système.
2. Télécharger le fichier Consul requis selon le système.

Décompresser les fichiers:

$ unzip vault_0.9.1_linux_amd64.zip
$ unzip consul_1.0.2_linux_amd64.zip
# mv vault /usr/local/bin
# mv consul /usr/local/bin

Créer un fichier de configuration pour Vault:

Le fichier de configuration de base est ceci:

storage "consul" {
  address = "127.0.0.1:8500"
  path = "vault"
}

listener "tcp" {
  address = "127.0.0.1:8200"
  tls_disable = 0
  tls_cert_file = "/etc/certs/vault.crt"
  tls_key_file  = "/etc/certs/vault.key"
}

On peut mettre cette configuration dans un fichier HCL, ex: vault.hcl.

Note: Si on a pas de certificat, on peut mettre tls_disable = 1, mais avec cette configuration, TLS n'est pas activé, donc les requêtes ne se feront pas en HTTPS. Correcte pour un environnement de développement/test, mais certainement pas en production.

Pour créer le certificat et la clé privée, suivre les instructions sur Créer un certificat signé par CA.

Démarrer Consul:

$ consul agent -server -bootstrap-expect 1 -data-dir /tmp/consul -bind 127.0.0.1

Démarrer Vault:

$ vault server -config=vault.hcl

S'il y une erreur Error initializing core: Failed to lock memory: cannot allocate memory, on peut exécuter cette commande:

$ sudo setcap cap_ipc_lock=+ep $(readlink -f $(which vault))

Voir disable_mlock pour plus d'info.

Pour se connecter au serveur en TLS avec le CLI, il faut spécifier VAULT_ADDR:

$ export VAULT_ADDR=https://127.0.0.1:8200

Ensuite, on peut faire:

$ vault operator init

Il faut noter les clés, idéalement à des endroits différents et elles-mêmes encryptées.

Après un init, Vault est en état Sealed. Il faut le déverrouiller en faisant:

$ vault operator unseal [unsealkey]

Par défaut, il faut entrer trois clés unseal différentes sur les cinq qui ont été donnés lors du vault init, ce qui signifie qu'il faut faire vault unseal trois fois.

Consul ne semble pas persister les données. Peut-être une mauvaise configuration ? Reste que c'est la configuration standard montrée dans les guides sur Vault. On peut alors plutôt choisir un storage en fichiers ou en base de données, malgré que MySQL et Postgresql sont supportés par la communauté.

Préférable donc d'utiliser un storage en fichiers :

storage "file" {
  path = "/mnt/vault/data"
}

Les données sont persistées et si le serveur redémarre, un init ne sera pas nécessaire.

sudo useradd -r -d /var/lib/vault -s /bin/nologin vault
sudo install -o vault -g vault -m 750 -d /var/lib/vault
sudo mkdir /etc/vault
sudo nano /etc/vault.file.hcl

storage "file" {
  path = "/var/lib/vault/data"
}

listener "tcp" {
  address = "127.0.0.1:8200"
  tls_disable = 0
  tls_cert_file = "/var/lib/vault/vault.crt"
  tls_key_file = "/var/lib/vault/vault.key"
}

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

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

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

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

[Install]
WantedBy=multi-user.target

Create a group for key access:

sudo groupadd pki

sudo chgrp pki /etc/vault/pki
sudo chmod g+rx /etc/vault/pki
sudo gpasswd -a vault pki

$ sudo systemctl start vault
$ sudo systemctl status vault

Source

Cette procédure prend en compte Vault 0.11.0 et Ubuntu 18.04.

• Compresser les données de /var/lib/vault/data.
• Compresser les données de /etc/vault.
• Copier le fichier /usr/local/share/ca-certificates/vault-root.crt.
• Copier le fichier de configuration d'Apache.

Voir la page de téléchargement pour la dernière version et télécharger le fichier Vault:

$ wget https://releases.hashicorp.com/vault/0.11.0/vault_0.11.0_linux_amd64.zip

Décompresser avec unzip (apt install unzip s'il n'y est pas) et déplacer vault:

$ sudo mv vault /usr/local/bin/

Ajouter le flag suivant pour que Vault puisse verrouiller la mémoire:

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

Pour vérifier que Vault fonctionne jusqu'à présent:

$ vault --version

Créer un utilisateur Vault:

$ sudo useradd -r -d /var/lib/vault -s /bin/nologin vault
$ sudo install -o vault -g vault -m 750 -d /var/lib/vault

Décompresser les fichiers tar aux endroits appropriés et donner les permissions correctes:

$ sudo chown vault:vault /etc/vault/vault.hcl

Ensuite, créer le fichier de configuration de systemctl:

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

Inclure ce contenu:

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

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

[Install]
WantedBy=multi-user.target

Par défaut, les certificats et les clés sont accessible que par root. Pour que ces certificats soit accessible par Vault, on crée un groupe pki qui permettra de le faire:

$ sudo groupadd pki
$ sudo chgrp pki /etc/vault/pki
$ sudo chmod g+rx /etc/vault/pki
$ sudo gpasswd -a vault pki

Copier le certificat root:

$ sudo mv vault-root.crt /usr/local/share/ca-certificates
$ sudo update-ca-certificates

Démarrer Vault:

$ sudo systemctl start vault

Unseal:

$ vault operator unseal <unseal-key-1>
$ vault operator unseal <unseal-key-n>

• Copier le fichier conf dans /etc/apache2/sites-available.
• Créer le répertoire /var/log/apache2/vault.sgy.io (chown root:root it)

On peut faire un autre secret backend:

$ vault mount kv
$ vault secrets enable kv //nouvelle commande

Ensuite on peut créer des secrets avec le principe key/value:

$ vault write kv/hello value=world
$ vault write kv/topsecretlogin user=root pass=god

Avec un fichier:

$ vault write kv/secretfile @secretfile.txt

On recommande d'encoder le fichier en Base64 avant de le stocker.

Pour avoir la liste des secrets :

$ vault list kv

Pour supprimer un secret:

$ vault delete kv/hello

$ vault token create [-policy="policyname"]
Key            	Value
---            	-----
token          	c4a0d45f-4a16-3e59-d5a0-c70e0efb2d23
token_accessor 	a05ba56e-e679-91d6-4e8c-bdc2217955dc
token_duration 	0s
token_renewable	false
token_policies 	[root]

S'authentifier avec un token:

$ vault login c4a0d45f-4a16-3e59-d5a0-c70e0efb2d23

$ vault token revoke c4a0d45f-4a16-3e59-d5a0-c70e0efb2d23

Documentation: Policies

Créer un fichier HCL comme celui-ci:

path "secret/app-name/*" {
  capabilities = ["create", "read", "update", "delete", "list"]
}

Après on peut créer le policy:

$ vault write sys/policy/policy-name policy=@app-name-policy.hcl

Autre façon:

$ vault policy write <policy-name> ./policy.hcl

Créer un token avec la policy:

$ vault token create -policy="app-name"

Voir le contenu d'une policy en particulier:

$ vault policy read [policyname]

Lister des policies:

$ vault policy list

Documentation: Auth Backend: AppRole

De base:

$ vault audit enable file file_path=/var/log/vault_audit.log

Utiliser screen pour basculer d'un shell à l'autre.

$ export VAULT_ADDR=https://127.0.0.1:8200
$ screen -S consul
$ consul agent -server -bootstrap-expect 1 -data-dir /tmp/consul -bind 127.0.0.1
[ctrl-a d]
$ screen -S vault
$ vault server --config=vault.file.hcl
[ctrl-a d]
$ vault init
$ vault operator unseal <key>
$ vault auth <token>
$ vault mount kv

• HashiCorp Vault: How to secure secrets inside microservices
• Using Hashicorp Vault as a PKI SSL/TLS CA