Aquilenet » Services

# Vaultwarden (bitwarden)

{{toc}}

Bitwarden est un gestionnaire de mot de passes réservé aux Jedi (les Padawan n'y ont pas accès)

Vaultwarden est la version Rust de Biwarden: https://github.com/dani-garcia/vaultwarden

Il est disponible sur: harpocrates et le port 8080 (anciennement sur https://coffre.aquilenet.fr/)

Donc forcément il vous faut un accès ssh sur la machine harpocrates pour utiliser l'outil.

Pour l'admin: http://localhost:8080/admin

Server: harpocrates

## Configuration

### Accès utilisateurs

On autorise l'inscription à tous les utilisateurs ayant un mail en **@aquilenet.fr** (et qui ont l'accès ssh à la machine harpocrates)

Pour valider son inscription un utilisateur doit confirmer via l'email reçu de vaultwarden.

Il est possible d'inviter des gens extérieurs via la page d'admin uniquement.

Une fois inscrit faire la demande à admin@aquilenet.fr pour se faire inviter dans l'organisation *Admin* de l'outil :

1. ajouter l'utilisateur à l'organisation *Admin* en tant que *Propriétaire* (saisir l'adresse mail que l'utilisateur a utilisée pour se créer son compte)

2. ajouter l'utilisateur à toutes les collections de l'organisation

3. lorsque la personne à ajouter a confirmé son ajout à l'organisation avec le mail qu'elle a reçu, il faut encore confirmer l'adhésion à l'organisation.

#### Accès via pc et navigateur

##### Le plus simple

Sur sa machine :

```sh

ssh -NL 8080:localhost:8080 coffre.aquilenet.fr

```

(la commande bloque, n'affiche rien, mais c'est normal) puis ouvrir son navigateur à l'adresse http://localhost:8080

##### Autre méthode

Cette méthode permet de passer par l'utilisateur `bitwarden` qui est très restreint : pas le droit d'ouvrir un shell interactif et utilisateur pas sudo.

*Mais*, cette méthode ne fonctionne actuellement pas : l'utilisateur `bitwarden` a un `$HOME` qui n'existe pas (plus). Le `$HOME` semble être dans `/var/www/bitwarden-old/`.

_Sur sa machine_

Créer une config ssh dédiée pour l'accès à vaultwarden via tunnel :

```sh

echo -e Host coffre.aquilenet.fr\\nPort 55555\\nUser bitwarden\\nIdentityFile ~/.ssh/id_ed25519_vaultwarden\\nLocalForward localhost:8080 localhost:8080\\nSessionType none >~/.ssh/coffre.conf

```

_Sur Harpocrates:_

Récupérer le couple de clef ssh non protégées de l'utilisateur non privilégié bitwarden (`/home/bitwarden/.ssh/{id_ed25519_vaultwarden,.pub}`).

Les copier dans le vôtre (ou modifier `~/.ssh/coffre.conf` avec vos login et clefs).

Cette configuration permet une connexion sans exécution d'un shell distant (SessionType none), d'autre part l'utilisateur bitwarden est configuré avec un "dummy shell" dans `/etc/passwd` qui ne permet pas de faire quoi que ce soit sur la machine (/home/bitwarden/Fake_Shell.sh).

lancer la connexion ssh (`ssh coffre`), puis pointer le navigateur sur `http://localhost:8080`.

#### Accès via pc en cli

Récupérer le binaire du client cli sur https://vault.bitwarden.com/download/?app=cli&platform=linux

(Ou installer via `npm` avec `npm install -g @bitwarden/cli`)

Décompresser l'archive par exemple dans ~/.Bitwarden_cli

Rendre exécutable le binaire : `chmod +x ~/.Bitwarden_cli/bw`

Modifier le PATH dans ~/.bashrc

`PATH=$PATH:~/.Bitwarden_cli`

Ajouter éventuellement un alias dans ~/.bashrc

`alias bw='bw --pretty'`

Lancer la connexion ssh sur coffre puis configurer le serveur Waultwarden avec :

`bw config server http://localhost:8080`

Connecter le client cli avec :

`bw login`

Rentrer login et password.

Comme proposé renseigner la variable d'environnement `BW_SESSION` avec `export BW_SESSION=....`

Synchroniser les données avec :

`bw sync`

La récupération d'un mot de passe root se fait par exemple avec :

`bw get password iris`

Dans certains cas il y a plusieurs réponses possible (cas pour harpocrates par exemple) et la liste des id est donnée.

On peut alors avoir le détail via :

`bw get item <id>`

`bw get uri <id>`

`bw get username <id>`

`bw get password <id>`

La vérification de la connexion se fait via :

`bw status`

La mise à jour du binaire se fait via :

`bw update`

La déconnexion se fait avec :

`bw logout`

#### Accès éventuel via ordiphone

Si on veux vraiment et si on en a le besoin réel et explicite, techniquement on peut.

Sur Android, utilisation de l'appli `ConnectBot` (https://play.google.com/store/apps/details?id=org.connectbot) pour l'accès via tunnel ssh et de l'appli bitwarden officielle.

Interdiction **_FORMELLE_**  d'utiliser son compte ssh habituel d'admin de l'infra pour cet usage !

**_OBLIGATION_** d'utiliser un compte dédié, non privilégié avec accès restreint.

Récupérer la clef publique non protégée (`/home/bitwarden/.ssh/id_ed25519_vaultwarden.pub`) ou en générer une nouvelle avec passphrase (simple à taper sur ordiphone) et dédiée à cet usage (`ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_vaultwarden`) et aller l'ajouter sur harpocrates dans `/home/bitwarden/.ssh/authorized_keys`

Copier cette clef sur l'ordiphone, puis l'importer dans l'appli ConnectBot et la protéger par passphrase si pas déjà le cas.

Menu en haut à droite puis "Gérer les clefs publiques" appuis sur le dossier en haut à droite, naviguer sur le support de stockage et sélectionner la clef publique.

Si pas fait avant, appuis long sur la clef et "Changer le mot de passe" (choisissez en une simple à taper sur ordiphone).

De retour sur le menu général, créer un nouveau serveur en cliquant sur le "+" en bas à droite

renseigner `bitwarden@coffre.aquilenet.fr:55555`

donner un nom à ce nouvel objet

sélectionner la clef dans "Utiliser une clef pour l'authentification"

décocher "Démarrer une session en ligne de commande" (seul le tunnel nous intéresse ici).

cocher éventuellement "Rester connecter"

Enregistrer en haut à droite (icône disquette).

Appuis long sur le serveur nouvellement créé, puis "éditer les redirections de port"

Ajout par "+"

Nom:vaultwarden

type local,

Port source : 8080

Destionation: localhost:8080

Enregistrer (Créer la redirection de port).

Lancer la connexion dans ConnectBot

taper la passphrasse

réduire l'appli

lancer l'appli bitwarden

la faire pointer sur http://localhost:8080 dans le menu de configuration en haut à droite

et enfin s'identifier sur le service.

### Accès admin

On accède à la page d'admin via un tunnel ssh et une redirection de port vers le 8080 et http://localhost:8080/admin

Un token est demandé, il est visible sur Harpocrates dans /var/www/bitwarden/docker-compose.yaml

On ajoute en sécurité supplémentaire une Basic Auth dans Nginx, le fichier de conf est: `/var/www/bitwarden/.htpasswd`

Il contient les admins de Harpocrates avec le même hash password du /etc/shadow

## Installation

Sur le serveur Harpocrates, on installe le service vaultwarden (initialement avec un reverse proxy nginx, désactivé depuis).

### installation du service

On peut le lancer via docker, builder manuellement le service ou utiliser un package .deb non officiel.

En ce moment la méthode .deb est utilisée.

#### Package .deb non officiel.

On peut trouver les packages:

- server: https://github.com/dionysius/vaultwarden-deb

- front web: https://github.com/dionysius/vaultwarden-web-vault-deb

il faut télécharger et installer les deux .deb via les releases.

```bash

VERSION=1.30.5

WEB_VERSION=2024.3.0

wget "https://github.com/dionysius/vaultwarden-deb/releases/download/debian%2F${VERSION}-0/vaultwarden_${VERSION}-0.bookworm_amd64.deb"

wget "https://github.com/dionysius/vaultwarden-web-vault-deb/releases/download/debian%2F${WEB_VERSION}-0/vaultwarden-web-vault_${WEB_VERSION}-0.bookworm_all.deb"

dpkg -i vaultwarden_${VERSION}-0.bookworm_amd64.deb vaultwarden-web-vault_${WEB_VERSION}-0.bookworm_all.deb

```

**Première installation**

1. Modifier le fichier `/etc/default/vaultwarden` pour y ajouter la config, par exemple on décommente:

```

WEB_VAULT_FOLDER=/usr/share/vaultwarden-web-vault/

WEBSOCKET_ENABLED=true

DOMAIN=http://localhost:8080

SENDS_ALLOWED=true

SIGNUPS_ALLOWED=true

SIGNUPS_VERIFY=true

SIGNUPS_DOMAINS_WHITELIST=aquilenet.fr

INVITATIONS_ALLOWED=true

INVITATION_ORG_NAME=Aquilenet

ADMIN_TOKEN=<THE ADMIN KEY>

DISABLE_ADMIN_TOKEN=false

SMTP_HOST=127.0.0.1

SMTP_FROM=vaultwarden@coffre.aquilenet.fr

SMTP_FROM_NAME="Vaultwarden (Ne pas répondre)"

SMTP_SECURITY=off

SMTP_PORT=25

HELO_NAME=coffre.aquilenet.fr

ROCKET_ADDRESS=127.0.0.1

ROCKET_PORT=8080

```

2. `systemctl enable vaultwarden && systemctl start vaultwarden`

**Mise à jour** (pas encore testé au 06/05/2024)

Télécharger les .deb et les installer, puis redémarrer le service vaultwarden `systemctl restrart vaultwarden`

#### via docker et docker compose (ancienne méthode).

1. Créer le dossier pour la data du service:

```

mkdir -p /srv/vw-data

chown -R bitwarden:bitwarden /srv/vw-data

```

2. On décrit le container docker à lancer via docker compose

`cat /var/www/bitwarden/docker-compose.yaml`

```yaml

version: '3'

services:

  vaultwarden:

    image: vaultwarden/server:1.25.2

    container_name: vaultwarden

    restart: always

    user: 1000:1000 # bitwarden user

    ports:

      - "127.0.0.1:8080:80"   # port app

      - "127.0.0.1:3012:3012" # port web socket

    environment:

      ADMIN_TOKEN: <Admin token> # token to connect to admin

      WEBSOCKET_ENABLED: "true"  # Enable WebSocket notifications.

      SIGNUPS_DOMAINS_WHITELIST: aquilenet.fr # on autorise seulement le @aquilenet.fr

      SIGNUPS_VERIFY: true

      INVITATIONS_ALLOWED: false  # Les utilisateurs ne peuvent pas inviter des non inscrits (seulement admin)

    volumes:

      - /srv/vw-data:/data

```

Il est possible de configurer d'autre choses via la page admin

3. Une fois docker installé, pour démarrer en background:

`cd /var/www/bitwarden/ && docker compose up -d`

(4. Mise à jour avec docker)

Ouvrir `/var/www/bitwarden/docker-compose.yaml`

changer `image: vaultwarden/server:<nouvelle version>`

Restart (avec docker):

```

cd /var/www/bitwarden/

docker compose down # Service sera étteint

docker compose up -d --force-recreate

```

#### Build et install (ancienne méthode).

Il faut compiler le service et le lancer dans un systemd:

Suivre: https://gist.github.com/heinoldenhuis/f8164f73e5bff048e76fb4fff2e824e1

Pour le build du 'web-vault', on peut utiliser dans bw_web_builds la cmd `make docker-extract`, il créera le dossier `docker_builds/web-vault` (pas besoin d'installer NodeJs de cette manière).

Install actuelle:

- systemd file: `/etc/systemd/system/vaultwarden.service`

- vaultwarden:

  - sources dir: /var/www/bitwarden/vaultwarden

  - binaire: /var/www/bitwarden/vaultwarden/target/release/vaultwarden

  - data dir: /var/www/bitwarden/vaultwarden/target/release/data

  - env file (config): /var/www/bitwarden/vaultwarden/target/release/.env

    - config: 

```

WEB_VAULT_FOLDER=/var/www/bitwarden/bw_web_builds/docker_builds/web-vault

WEBSOCKET_ENABLED=true

SIGNUPS_VERIFY=true

SIGNUPS_DOMAINS_WHITELIST=aquilenet.fr

ADMIN_TOKEN=<admin token>

INVITATIONS_ALLOWED=false

ROCKET_ADDRESS=127.0.0.1

```

- web-vault

  - sources dir: /var/www/bitwarden/bw_web_builds/

  - build dir: /var/www/bitwarden/bw_web_builds/docker_builds/web-vault

### Reverse proxy Nginx

Le site était configuré dans `/etc/nginx/sites-available/coffre.aquilenet.fr.conf`

Les certificats étaient gérés par certbot (cf `sudo certbot certificates`)

### Config SMTP

Il faut configurer une connexion SMTP pour que vaultwarden puisse envoyer des mails.

Sur une VM vierge: 

- enlever exim4

- installer postfix

- enlever params d'authent pour envoyer sur localhost:25

Conf vaultwarden SMTP (dans l'interface admin de vaultwarden):

```

  "smtp_host": "127.0.0.1",

  "smtp_security": "off",

  "smtp_port": 25,

  "smtp_from": "vaultwarden@aquilenet.fr",

  "smtp_from_name": "Vaultwarden (Ne pas répondre)",

  "smtp_timeout": 15,

  "helo_name": "coffre.aquilenet.fr",

  "smtp_accept_invalid_certs": false,

  "smtp_accept_invalid_hostnames": false,

```