Bitwarden : gestionnaire de mots de passe open-source et Secrets Manager

Bitwarden centralise vos mots de passe avec un chiffrement de bout en bout (AES-256). C'est l'un des gestionnaires de mots de passe open-source les plus populaires, avec deux produits complémentaires : le Password Manager pour stocker vos identifiants, et le Secrets Manager pour automatiser la gestion des secrets dans vos pipelines CI/CD.

Le problème des mots de passe en équipe

Une équipe DevOps gère couramment des dizaines de services : bases de données, API tierces, comptes cloud, certificats. Chacun possède ses propres credentials, et la question du partage se pose dès le deuxième ingénieur qui doit intervenir.

Les pratiques courantes sont toutes problématiques :

Fichiers texte partagés, Aucun chiffrement, aucun historique, aucune trace d'accès
Tableurs Excel, Circulent par email, finissent dans des dossiers publics
Messages Slack/Teams, Stockés en clair dans les logs, impossibles à révoquer
Variables d'environnement en dur, Finissent dans les commits Git, exposées dans les logs CI

Bitwarden résout ce problème avec deux approches complémentaires :

Password Manager, Pour les humains. Vous stockez, partagez et gérez vos identifiants via une interface web, des extensions navigateur et des applications mobiles.
Secrets Manager, Pour les machines. Vos applications et pipelines CI/CD récupèrent automatiquement les secrets dont ils ont besoin, sans intervention humaine.

Deux produits, deux cas d'usage

Bitwarden n'est pas un produit unique décliné en options : ce sont deux applications distinctes, avec leur propre modèle de données, leur propre CLI et leur propre facturation. Les confondre est l'erreur la plus fréquente au moment de choisir un plan. La ligne de partage tient en une phrase : le Password Manager sert les personnes, le Secrets Manager sert les programmes.

Password Manager

C'est le cœur de Bitwarden. Il permet de :

Stocker des mots de passe, notes sécurisées, cartes bancaires, identités
Générer des mots de passe forts automatiquement
Partager des identifiants avec votre équipe via des organisations
Synchroniser sur tous vos appareils (web, desktop, mobile, navigateur)
Exporter/Importer depuis LastPass, 1Password, KeePass et autres

Le Password Manager utilise un chiffrement AES-256 avec PBKDF2-SHA256 (600 000 itérations par défaut). Vos données sont chiffrées avant d'être envoyées au serveur. Même Bitwarden ne peut pas les lire.

Secrets Manager

Lancé en 2023, le Secrets Manager est conçu pour les développeurs et les équipes DevOps. Il permet de :

Centraliser les secrets applicatifs (clés API, tokens, connexions DB)
Organiser les secrets par projets
Contrôler les accès via des comptes machines (machine accounts)
Injecter les secrets dans vos applications via la CLI bws
Auditer qui a accédé à quoi et quand (logs)

Choisir son édition

Bitwarden propose plusieurs plans, du gratuit à l'entreprise. Le choix dépend de vos besoins en fonctionnalités et du nombre d'utilisateurs.

Pour les individus

Les plans individuels se distinguent surtout par le TOTP intégré (les codes à usage unique de la double authentification) et par le stockage de fichiers, tous deux absents du plan gratuit.

Plan	Prix	Fonctionnalités clés
Free	Gratuit	Mots de passe illimités, 2 appareils, partage avec 1 personne
Premium	10$/an	TOTP intégré, 1 Go stockage fichiers, rapports de sécurité
Families	40$/an	6 utilisateurs, partage illimité, toutes les fonctionnalités Premium

Pour les équipes

Le passage de Teams à Enterprise se justifie principalement par le SSO (l'authentification unique via SAML ou OIDC) et par SCIM, qui synchronise automatiquement les comptes depuis votre annuaire au lieu de les créer à la main.

Plan	Prix	Fonctionnalités clés
Teams	4$/user/mois	Partage équipe, groupes, journaux d'audit, 2FA avancé
Enterprise	6$/user/mois	SSO (SAML/OIDC), SCIM, politiques personnalisées, Key Connector

Secrets Manager

Le Secrets Manager se facture séparément du Password Manager, par packs de secrets. Les machine accounts inclus plafonnent le nombre d'identités non humaines, c'est-à-dire en pratique le nombre de pipelines ou d'applications distincts que vous pourrez brancher sans surcoût.

Plan	Secrets	Machine accounts	Prix
Teams	6 000	20 inclus	6$/mois (pack de 500 secrets)
Enterprise	12 000	50 inclus	12$/mois (pack de 500 secrets)

Partie 1 : Installation avec Docker Compose

Docker Compose est la méthode la plus simple pour déployer Bitwarden en self-hosted.

Prérequis

Docker Engine 20.10+ avec Docker Compose
4 Go de RAM minimum (8 Go recommandé)
Ports 80 et 443 disponibles
Un nom de domaine pointant vers votre serveur
Un serveur SMTP pour les notifications

Obtenir les identifiants d'installation

Avant d'installer, vous devez obtenir un ID d'installation et une clé d'installation gratuits sur le site Bitwarden.

Rendez-vous sur la page d'hébergement

Ouvrez https://bitwarden.com/host dans votre navigateur.
Remplissez le formulaire
- Entrez votre adresse email
- Sélectionnez votre région (Europe ou États-Unis)
- Cochez la case d'acceptation des conditions
Récupérez vos identifiants

Vous recevrez par email :
- Installation ID : un UUID (ex: a1b2c3d4-e5f6-7890-abcd-ef1234567890)
- Installation Key : une clé secrète
Conservez ces identifiants, vous en aurez besoin lors de l'installation.

Installation

L'installation officielle repose sur un script bitwarden.sh qui génère la configuration Docker Compose et pilote ensuite le cycle de vie de la pile (start, stop, update). Comptez une dizaine de conteneurs au total. La séquence ci-dessous couvre la mise en place complète, du compte système dédié jusqu'à la création du premier utilisateur.

Créer un utilisateur dédié

Pour des raisons de sécurité, créez un utilisateur système dédié à Bitwarden :
Fenêtre de terminal
```
sudo adduser bitwarden
sudo usermod -aG docker bitwarden
```

Créer le répertoire d'installation

sudo mkdir -p /opt/bitwarden
sudo chown -R bitwarden:bitwarden /opt/bitwarden
sudo chmod 700 /opt/bitwarden

Télécharger le script d'installation

Connectez-vous en tant que l'utilisateur bitwarden et téléchargez le script :

su - bitwarden
cd /opt/bitwarden
curl -Lso bitwarden.sh "https://func.bitwarden.com/api/dl/?app=self-host&platform=linux"
chmod +x bitwarden.sh

Lancer l'installation
Fenêtre de terminal
```
./bitwarden.sh install
```
Le script vous demandera :
- Votre nom de domaine (ex: bitwarden.example.com)
- Votre Installation ID et Installation Key
- Si vous souhaitez utiliser Let's Encrypt pour le certificat SSL (recommandé)
- Votre région (EU ou US)
Configurer l'environnement

Éditez le fichier de configuration pour ajuster les paramètres :
Fenêtre de terminal
```
nano ./bwdata/env/global.override.env
```
Configurez au minimum le serveur SMTP pour les emails :
Fenêtre de terminal
```
globalSettings__mail__smtp__host=smtp.example.com
globalSettings__mail__smtp__port=587
globalSettings__mail__smtp__ssl=true
globalSettings__mail__smtp__username=notifications@example.com
globalSettings__mail__smtp__password=VotreMotDePasseSMTP
```
Sans configuration SMTP, vous ne pourrez pas créer de compte ni réinitialiser les mots de passe. Configurez-le avant le premier démarrage.
Configurer les administrateurs

Toujours dans global.override.env, ajoutez les emails des administrateurs :
Fenêtre de terminal
```
adminSettings__admins=admin@example.com,ops@example.com
```
Ces utilisateurs auront accès au portail d'administration système.
Démarrer Bitwarden
Fenêtre de terminal
```
./bitwarden.sh start
```
Le premier démarrage prend 2-3 minutes pour initialiser les conteneurs.
Créer le premier compte
- Ouvrez https://bitwarden.example.com dans votre navigateur
- Cliquez sur Créer un compte
- Entrez votre email et créez un mot de passe maître fort

Vérification :

# Vérifier que tous les conteneurs sont en cours d'exécution
docker ps --filter "name=bitwarden"

# Vérifier les logs
./bitwarden.sh logs

Vous devriez voir une dizaine de conteneurs en cours d'exécution : bitwarden-nginx, bitwarden-api, bitwarden-web, etc.

Partie 2 : CLI Password Manager

L'interface web est pratique pour le quotidien, mais elle ne suffit pas pour l'automatisation. La CLI bw permet de gérer vos mots de passe en ligne de commande : création en lot, récupération dans des scripts, export automatisé.

Installation de la CLI

La CLI bw est distribuée sous quatre formes au choix : binaire autonome, paquet npm, formule Homebrew ou snap. Le contenu est identique, seule la mise à jour diffère. Retenez que la version du client doit rester compatible avec celle de votre serveur self-hosted.

# Télécharger le binaire
curl -L "https://bitwarden.com/download/?app=cli&platform=linux" -o bw.zip
unzip bw.zip
chmod +x bw
sudo mv bw /usr/local/bin/

# Vérification
bw --version
# 2026.1.0

npm install -g @bitwarden/cli
bw --version

brew install bitwarden-cli

sudo snap install bw

Configuration du serveur

Par défaut, la CLI se connecte aux serveurs cloud de Bitwarden. Pour utiliser votre serveur self-hosted :

# Configurer l'URL du serveur
bw config server https://bitwarden.example.com

# Vérifier la configuration
bw status --pretty
# {
#   "serverUrl": "https://bitwarden.example.com",
#   "lastSync": null,
#   "status": "unauthenticated"
# }

Authentification

La CLI utilise un système de sessions. Vous vous authentifiez une fois, puis utilisez un token de session pour les commandes suivantes.

Se connecter

bw login

Entrez votre email, mot de passe maître et code 2FA si activé.

Résultat :

You are logged in!

To unlock your vault, set your session key to the `BW_SESSION` environment variable. ex:
$ export BW_SESSION="5PBYGU+5yt3RHcCjoeJKx/wByU34vokGRZjXpSH7Ylo8w=="

Définir la variable de session
Fenêtre de terminal
```
export BW_SESSION="5PBYGU+5yt3RHcCjoeJKx/wByU34vokGRZjXpSH7Ylo8w=="
```
Cette variable permet d'exécuter les commandes sans ressaisir le mot de passe maître.
Synchroniser le coffre
Fenêtre de terminal
```
bw sync
# Syncing complete.
```

Pour les scripts automatisés, utilisez une clé API personnelle au lieu du mot de passe :

export BW_CLIENTID="user.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
export BW_CLIENTSECRET="votre-client-secret"
bw login --apikey

Récupérez votre clé API dans les paramètres de votre compte web.

Commandes essentielles

La CLI suit une structure simple : bw <commande> <objet> [options]. Les commandes principales sont list, get, create, edit, delete. Les objets sont items, folders, collections, etc.

Lister les éléments

list items renvoie du JSON sur la sortie standard, mots de passe en clair compris. Redirigez cette sortie vers un traitement plutôt que de l'afficher telle quelle dans un terminal partagé ou enregistré.

# Lister tous les éléments du coffre
bw list items

# Filtrer par recherche
bw list items --search "github"

# Filtrer par dossier
bw list items --folderid 60556c31-e649-4b5d-8daf-fc1c391a1bf2

# Afficher en JSON formaté
bw list items --pretty

Récupérer un mot de passe

bw get accepte soit un nom approximatif, soit un identifiant exact. Avec un nom, la commande échoue dès que plusieurs éléments correspondent : dans un script, l'identifiant est la seule forme fiable.

# Récupérer par nom (recherche)
bw get password github.com

# Récupérer par ID exact
bw get item 99ee88d2-6046-4ea7-92c2-acac464b1412

# Récupérer uniquement le mot de passe (pour scripts)
bw get password github.com
# G#kL9$mP2xNq!

# Récupérer le username
bw get username github.com
# johndoe

Créer un élément

La création utilise un template JSON encodé en base64 :

# Obtenir le template d'un élément
bw get template item

# Créer un élément en ligne de commande
bw get template item | \
  jq '.name="Mon Service" | .login.username="admin" | .login.password="MonMotDePasse123"' | \
  bw encode | bw create item

# Créer un dossier
echo '{"name":"Production"}' | bw encode | bw create folder

Générer un mot de passe

bw generate produit une valeur mais ne l'enregistre pas dans le coffre : c'est à vous de la stocker ensuite. Les options se combinent librement, et le mode passphrase reste le plus adapté quand un humain devra saisir le secret à la main.

# Mot de passe par défaut (14 caractères, majuscules, minuscules, chiffres)
bw generate
# DWCosTPW#hLWZ6

# Mot de passe complexe de 24 caractères avec caractères spéciaux
bw generate -ulns --length 24
# DWCosTPW#hLWZ6i%2D!OlA3z

# Passphrase de 5 mots
bw generate -p --words 5 --separator - -c
# Valiant-Rubble-Bonus-Enlarged-Implicit

Les options de génération :

-u, --uppercase : inclure majuscules
-l, --lowercase : inclure minuscules
-n, --number : inclure chiffres
-s, --special : inclure caractères spéciaux
-p, --passphrase : générer une passphrase
--words <n> : nombre de mots (passphrase)
--separator <char> : séparateur entre les mots

Bitwarden Send

Send permet de partager des fichiers ou du texte de manière sécurisée avec expiration automatique :

# Envoyer du texte (expire dans 7 jours par défaut)
bw send -n "API Key" "sk_live_xxxxxxxxxxxxx"

# Envoyer un fichier (expire dans 14 jours)
bw send -n "Certificat SSL" -f ./cert.pem -d 14

# Envoyer avec mot de passe
bw send -n "Credentials" --password "MotDePassePartage" "admin:secret123"

# Lister les envois
bw send list

Le destinataire reçoit un lien unique pour accéder au contenu, sans avoir besoin de compte Bitwarden.

Exporter le coffre

L'export écrit un fichier local, donc hors du périmètre chiffré de Bitwarden. C'est l'opération la plus risquée de toute la CLI, comme le rappelle l'avertissement qui suit les commandes.

# Export CSV
bw export --format csv --output ./backup.csv

# Export JSON chiffré (recommandé pour les sauvegardes)
bw export --format encrypted_json --password "MotDePasseExport" --output ./backup.json

Partie 3 : Secrets Manager pour DevOps

Le Password Manager est conçu pour les humains. Mais comment vos applications récupèrent-elles leurs secrets ? C'est le rôle du Secrets Manager et de sa CLI bws.

Concepts clés

Le Secrets Manager utilise une architecture différente du Password Manager :

Concept	Description
Secret	Une paire clé-valeur sensible (ex: `DATABASE_URL=postgres://...`)
Project	Un groupe logique de secrets (ex: "Production", "Staging")
Machine Account	Un compte non-humain qui accède aux secrets (ex: votre pipeline CI)
Access Token	La clé d'authentification d'un machine account

Le flux est le suivant :

Vous créez des projets et y ajoutez des secrets via l'interface web
Vous créez un machine account avec accès à certains projets
Vous générez un access token pour ce machine account
Votre application utilise ce token pour récupérer les secrets via la CLI bws

Installation de la CLI bws

bws est un binaire indépendant de bw : les deux outils ne partagent ni configuration, ni session, ni format d'authentification. Installez bws sur les machines qui exécutent vos pipelines, pas sur les postes de travail.

Linux (binaire)
Docker

# Télécharger la dernière version
VERSION="2.0.0"
curl -LO "https://github.com/bitwarden/sdk-sm/releases/download/bws-v${VERSION}/bws-x86_64-unknown-linux-gnu-${VERSION}.zip"
unzip bws-x86_64-unknown-linux-gnu-${VERSION}.zip
chmod +x bws
sudo mv bws /usr/local/bin/

# Vérification
bws --version
# bws 2.0.0

docker run --rm -it bitwarden/bws --help

Configuration

La mise en route se fait entièrement dans l'interface web, dans cet ordre : activer le produit, créer un projet, y déposer des secrets, puis déclarer le machine account autorisé à les lire. Le token généré à la dernière étape est la seule information que votre pipeline aura besoin de connaître.

Activer Secrets Manager

Dans l'interface web Bitwarden, allez dans Admin Console → Billing → Subscription et activez Secrets Manager pour votre organisation.
Créer un projet

Dans le menu de gauche, cliquez sur Projects → New Project :
- Nom : production
- Description : Secrets de l'environnement de production

Ajouter des secrets

Dans le projet, cliquez sur Secrets → Create Secret :

Key: DATABASE_URL
Value: postgres://app:secret@db.internal:5432/myapp
Note: Connexion base PostgreSQL production

Créer un machine account

Allez dans Machine Accounts → New Machine Account :
- Nom : ci-production
- Accès : projet production avec permission Can read
Générer un access token

Dans le machine account, onglet Access Tokens :
- Cliquez sur Create Access Token
- Nom : gitlab-runner-01
- Expiration : selon vos besoins (ou "Never" pour les tests)
Copiez le token immédiatement, il ne sera plus affiché.

Commandes essentielles

La CLI bws s'organise autour d'un objet unique, le secret, et d'une commande d'exécution run. Toutes les sous-commandes exigent un access token valide, transmis par variable d'environnement ou en option.

Authentification

La variable BWS_ACCESS_TOKEN est la forme à privilégier : passer le token en argument le rend visible dans la sortie de ps et dans l'historique du shell, donc lisible par tout utilisateur de la machine.

# Via variable d'environnement (recommandé)
export BWS_ACCESS_TOKEN="0.48c78342-1635-48a6-accd-afbe01336365.C0tMmQqHnAp..."

# Via option en ligne de commande
bws secret list --access-token "0.48c78342..."

Lister les secrets

Sans argument, la commande retourne tous les secrets auxquels le machine account a accès. Le format env produit directement des lignes KEY=VALUE, exploitables par un source dans un script shell.

# Lister tous les secrets accessibles
bws secret list

# Lister les secrets d'un projet spécifique
bws secret list e325ea69-a3ab-4dff-836f-b02e013fe530

# Format de sortie
bws secret list --output table
bws secret list --output yaml
bws secret list --output env  # Format KEY=VALUE

Récupérer un secret

bws secret get attend l'identifiant du secret, pas son nom. Récupérez cet UUID une première fois avec bws secret list, puis figez-le dans votre configuration : il ne change pas quand la valeur du secret est mise à jour.

# Récupérer un secret par son ID
bws secret get be8e0ad8-d545-4017-a55a-b02f014d4158

# Sortie JSON par défaut :
# {
#   "id": "be8e0ad8-d545-4017-a55a-b02f014d4158",
#   "key": "DATABASE_URL",
#   "value": "postgres://app:secret@db.internal:5432/myapp",
#   "note": "Connexion base PostgreSQL production",
#   ...
# }

# Extraire uniquement la valeur (pour scripts)
bws secret get be8e0ad8-... --output tsv | cut -f4

Créer un secret

Les trois arguments positionnels sont obligatoires et attendus dans cet ordre : la clé, la valeur, puis l'identifiant du projet. Attention, la valeur apparaît en clair dans la ligne de commande, donc dans l'historique du shell.

# Créer un nouveau secret
bws secret create API_KEY "sk_live_xxxxxxxxxxxxx" e325ea69-a3ab-4dff-836f-b02e013fe530 \
  --note "Clé API Stripe production"

# Paramètres :
# - KEY : nom du secret
# - VALUE : valeur du secret
# - PROJECT_ID : UUID du projet

Injecter des secrets dans une commande

La commande bws run est la plus puissante. Elle récupère tous les secrets accessibles et les injecte comme variables d'environnement dans la commande spécifiée :

# Exécuter une commande avec les secrets injectés
bws run -- 'npm run start'

# Les secrets deviennent des variables d'environnement :
# DATABASE_URL, API_KEY, etc. sont accessibles dans l'application

# Limiter aux secrets d'un projet
bws run --project-id e325ea69-a3ab-4dff-836f-b02e013fe530 -- 'python app.py'

# Utiliser un shell spécifique
bws run --shell bash -- '/path/to/script.sh'

Intégration CI/CD

Le principe reste le même quel que soit le moteur de CI : seul le token du machine account est stocké comme variable secrète du dépôt, et bws run injecte tous les autres au moment de l'exécution. Aucun secret applicatif n'a donc besoin d'être dupliqué dans la configuration du pipeline, ce qui supprime le travail de synchronisation à chaque rotation.

GitLab CI

L'image officielle bitwarden/bws embarque déjà la CLI, ce qui évite une étape d'installation dans le job.

variables:
  BWS_ACCESS_TOKEN: $BWS_TOKEN  # Défini dans les variables CI/CD GitLab

deploy:
  image: bitwarden/bws:1.0.0
  script:
    - bws run -- ./deploy.sh

GitHub Actions

Sur un runner GitHub, la CLI n'est pas préinstallée : le workflow la télécharge lui-même. Le token n'est exposé que dans le bloc env de l'étape qui en a besoin, et non au niveau du job entier.

name: Deploy

permissions: {}

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: read
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
        with:
          persist-credentials: false

      - name: Install bws
        run: |
          VERSION=2.0.0
          curl -fsSLO "https://github.com/bitwarden/sdk-sm/releases/download/bws-v$VERSION/bws-x86_64-unknown-linux-gnu-$VERSION.zip"
          curl -fsSLO "https://github.com/bitwarden/sdk-sm/releases/download/bws-v$VERSION/bws-sha256-checksums-$VERSION.txt"
          grep " bws-x86_64-unknown-linux-gnu-$VERSION.zip$" "bws-sha256-checksums-$VERSION.txt" | sha256sum -c -
          unzip "bws-x86_64-unknown-linux-gnu-$VERSION.zip"
          chmod +x bws && sudo mv bws /usr/local/bin/

      - name: Deploy with secrets
        env:
          BWS_ACCESS_TOKEN: ${{ secrets.BWS_ACCESS_TOKEN }}
        run: bws run -- ./deploy.sh

Partie 4 : Comparaison avec les alternatives

Ces trois outils répondent à des besoins qui se recoupent partiellement sans se confondre. Le tableau compare ce qui les sépare réellement : le périmètre couvert, le modèle de chiffrement et la présence d'un client pour chaque usage. Un tiret signale une fonctionnalité absente du produit.

Critère	Bitwarden	Passbolt	HashiCorp Vault
Type	Password Manager + Secrets Manager	Password Manager	Secrets Management
Chiffrement	AES-256	GPG (bout en bout)	AES-256-GCM
Open source	Oui	Oui	Oui (core)
CLI Password	`bw`	`go-passbolt-cli`	-
CLI Secrets	`bws`	-	`vault`
Interface web	Oui, complète	Oui, complète	Oui
Extensions navigateur	Oui, tous	Chrome, Firefox	-
Mobile	iOS, Android	Non	-
Self-hosted	Docker	Docker	Docker
SSO	Enterprise	Pro	Oui
Prix entrée	Gratuit	Gratuit	Gratuit

Quand choisir Bitwarden :

Vous voulez un gestionnaire complet (passwords + secrets)
Vous avez besoin d'applications mobiles et extensions navigateur
Vous souhaitez un déploiement simple (Docker Compose tout-en-un)

Quand choisir Passbolt :

Vous privilégiez le chiffrement GPG (bout en bout sans clé côté serveur)
Vous n'avez pas besoin d'applications mobiles
Vous préférez une installation plus légère

Quand choisir Vault :

Vous avez besoin de secrets dynamiques (credentials éphémères)
Vous gérez de l'infrastructure as code complexe
Vous avez des besoins avancés (PKI, transit encryption)

Dépannage

La quasi-totalité des blocages vient de deux sources : une session expirée côté bw, ou un certificat TLS que le client refuse. Le tableau donne la correspondance directe entre le message affiché et le geste correctif, sans passer par les journaux du serveur.

Symptôme	Cause probable	Solution
`unauthenticated` après login	Session expirée	Refaire `bw unlock` et exporter `BW_SESSION`
`Error: self-signed certificate`	Certificat SSL self-signed	Configurer Let's Encrypt ou `NODE_EXTRA_CA_CERTS`
SMTP errors au démarrage	Configuration SMTP manquante	Vérifier `global.override.env`
`Session key is invalid`	Token de session incorrect	Refaire `bw login` puis `bw unlock`
`bws: command not found`	CLI pas dans le PATH	`sudo mv bws /usr/local/bin/`
`Access denied` sur bws	Token expiré ou permissions	Vérifier le machine account

Vérifier les conteneurs Docker

Le script bitwarden.sh sert aussi d'outil de diagnostic. Il doit être lancé depuis le répertoire d'installation, faute de quoi il ne trouve pas le dossier bwdata qui contient toute la configuration générée.

# Statut des conteneurs
cd /opt/bitwarden && ./bitwarden.sh status

# Logs récents
./bitwarden.sh logs

# Redémarrer
./bitwarden.sh restart

Vérifier la CLI

bw status renvoie l'un des trois états possibles : unauthenticated, locked ou unlocked. Un coffre simplement verrouillé se rouvre avec bw unlock, sans repasser par bw login.

# Statut de connexion
bw status --pretty

# Forcer la synchronisation
bw sync --force

# Reconfigurer le serveur
bw config server https://bitwarden.example.com

À retenir

Deux produits complémentaires, Password Manager pour les humains, Secrets Manager pour les machines
Chiffrement AES-256, Vos données sont chiffrées côté client avant l'envoi
CLI Password Manager (bw), Génération (generate), récupération (get), création (create), partage (send)
CLI Secrets Manager (bws), Injection de secrets (run), CRUD (secret list/get/create)
Self-hosted possible, Docker Compose avec script d'installation officiel
Open source, Code audité, communauté active, audits de sécurité réguliers (Cure53)
Gratuit pour commencer, Plans gratuits suffisants pour les petites équipes

Prochaines étapes

Passbolt Alternative avec chiffrement GPG bout en bout

HashiCorp Vault Secrets dynamiques et PKI pour l'infrastructure

SOPS Chiffrer les secrets dans Git