Passbolt : gestionnaire de mots de passe open-source pour équipes

Passbolt centralise vos mots de passe avec un chiffrement de bout en bout (GPG). Contrairement aux gestionnaires grand public, il est conçu pour les équipes : partage sécurisé, groupes, API REST complète, et CLI pour l’automatisation.

Le problème des mots de passe en équipe

Imaginez une équipe DevOps qui gère des dizaines de services : bases de données, API tierces, comptes cloud, certificats. Chaque service a ses propres credentials. Comment les partager sans risque ?

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
Post-its sur l’écran — On en rit, mais ça existe encore

Passbolt résout ce problème en combinant trois principes :

Chiffrement de bout en bout — Les mots de passe sont chiffrés avec GPG avant d’arriver sur le serveur. Même un administrateur malveillant ne peut pas les lire.
Partage granulaire — Vous décidez qui voit quoi : lecture seule, modification, ou propriétaire. Par utilisateur ou par groupe.
Automatisation native — Une CLI et une API REST permettent d’intégrer Passbolt dans vos scripts et pipelines CI/CD.

Trois façons d’utiliser Passbolt

Interface web — Pour le quotidien. Vous créez, recherchez et partagez des mots de passe via une extension navigateur. L’extension déchiffre les secrets localement avec votre clé GPG.

CLI go-passbolt — Pour les DevOps. Vous automatisez la gestion des secrets : création en lot, récupération dans un script, injection dans des variables d’environnement. Idéal pour les pipelines CI/CD. ✅ Testé et fonctionnel avec Passbolt v5.x.

API REST — Pour l’intégration profonde. Terraform fonctionne parfaitement via le provider Bald1nh0/passbolt. Le module Ansible anatomicjc.passbolt rencontre actuellement une incompatibilité avec les clés GPG de Passbolt v5.x — utilisez la CLI en workaround.

Choisir son édition

Passbolt existe en trois versions. Le choix dépend de vos besoins en fonctionnalités et de votre capacité à héberger l’outil.

Community Edition (CE) — C’est la version open-source gratuite. Elle couvre les besoins essentiels : partage par groupes, CLI, API, historique des secrets. C’est celle que nous installons dans ce guide. Parfaite pour découvrir l’outil ou pour une petite équipe.

Pro Edition — Ajoute les fonctionnalités entreprise : authentification multi-facteur (MFA), intégration LDAP/Active Directory, journaux d’audit, rôles personnalisés (RBAC). Indispensable si vous devez prouver la conformité à un auditeur.

Cloud — Passbolt héberge le serveur pour vous. Vous n’avez rien à installer ni maintenir. Pratique pour démarrer vite, mais sans intégration LDAP.

Critère	Community Edition	Pro Edition	Cloud
Coût	Gratuit	30€/mois (10 users)	9€/mois (3 users)
Hébergement	Self-hosted	Self-hosted	Passbolt
CLI & API	✅	✅	✅
Partage groupes	✅	✅	✅
MFA (TOTP/WebAuthn)	❌	✅	✅
LDAP/AD	❌	✅	❌
Audit logs	❌	✅	✅
Secret history	✅	✅	✅
Dynamic roles (RBAC)	❌	✅	✅
SCIM provisioning	❌	✅ (beta)	✅ (beta)

Recommandation :

Situation	Édition conseillée
Petite équipe, budget limité	Community Edition
Besoin de MFA, audit, LDAP	Pro Edition
Pas d’infra, démarrage rapide	Cloud

Partie 1 : Installation avec Docker Compose

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

Prérequis

Docker Engine 20.10+ avec Docker Compose
2 Go de RAM minimum
Ports 80 et 443 disponibles (ou 8080/8443 pour un lab)
Un serveur SMTP pour les notifications (optionnel en lab)

Installation

Télécharger le docker-compose officiel

mkdir -p ~/passbolt && cd ~/passbolt
curl -LO https://download.passbolt.com/ce/docker/docker-compose-ce.yaml
curl -LO https://github.com/passbolt/passbolt_docker/releases/latest/download/docker-compose-ce-SHA512SUM.txt

# Vérifier l'intégrité (supply chain !)
sha512sum -c docker-compose-ce-SHA512SUM.txt
# docker-compose-ce.yaml: OK

Personnaliser la configuration

Éditez docker-compose-ce.yaml pour :

Épingler la version (pas de latest en prod)
Configurer l’URL (APP_FULL_BASE_URL)
Configurer le SMTP pour les notifications

services:
  db:
    image: mariadb:10.11
    restart: unless-stopped
    environment:
      MYSQL_RANDOM_ROOT_PASSWORD: "true"
      MYSQL_DATABASE: "passbolt"
      MYSQL_USER: "passbolt"
      MYSQL_PASSWORD: "VotreMotDePasseSecurise"
    volumes:
      - database_volume:/var/lib/mysql

  passbolt:
    # Toujours épingler la version !
    image: passbolt/passbolt:5.9.0-1-ce
    restart: unless-stopped
    depends_on:
      - db
    environment:
      APP_FULL_BASE_URL: https://passbolt.example.com
      DATASOURCES_DEFAULT_HOST: "db"
      DATASOURCES_DEFAULT_USERNAME: "passbolt"
      DATASOURCES_DEFAULT_PASSWORD: "VotreMotDePasseSecurise"
      DATASOURCES_DEFAULT_DATABASE: "passbolt"
      # Configuration SMTP
      EMAIL_DEFAULT_FROM: "passbolt@example.com"
      EMAIL_TRANSPORT_DEFAULT_HOST: "smtp.example.com"
      EMAIL_TRANSPORT_DEFAULT_PORT: "587"
      EMAIL_TRANSPORT_DEFAULT_TLS: "true"
    volumes:
      - gpg_volume:/etc/passbolt/gpg
      - jwt_volume:/etc/passbolt/jwt
    ports:
      - 443:443
      - 80:80

volumes:
  database_volume:
  gpg_volume:
  jwt_volume:

Démarrer les conteneurs
Fenêtre de terminal
```
docker compose -f docker-compose-ce.yaml up -d
```
Attendez 30-60 secondes que Passbolt initialise la base de données.

Créer le premier administrateur

docker compose -f docker-compose-ce.yaml exec passbolt su -m -c \
  "/usr/share/php/passbolt/bin/cake passbolt register_user \
    -u admin@example.com \
    -f Prénom \
    -l Nom \
    -r admin" \
  -s /bin/sh www-data

Résultat :

     ____                  __          ____
    / __ \____  _____ ____/ /_  ____  / / /_
   / /_/ / __ `/ ___/ ___/ __ \/ __ \/ / __/
  / ____/ /_/ (__  |__  ) /_/ / /_/ / / /
 /_/    \__,_/____/____/_.___/\____/_/\__/

 Open source password manager for teams
-------------------------------------------------------------------------------
User saved successfully.
To start registration follow the link provided in your mailbox or here:
https://passbolt.example.com/setup/start/1e61fe1f-1423-40ff-878e.../85101a2b...

Finaliser l’inscription
- Ouvrez le lien dans votre navigateur
- Installez l’extension Passbolt (Chrome, Firefox ou Edge)
- Créez votre passphrase (mot de passe maître)
- Téléchargez le kit de récupération (clé privée GPG)
- Configurez le jeton de sécurité (3 lettres + couleur)

Vérification :

# Statut des conteneurs
docker compose -f docker-compose-ce.yaml ps

# Healthcheck complet
docker compose -f docker-compose-ce.yaml exec passbolt su -m -c \
  "/usr/share/php/passbolt/bin/cake passbolt healthcheck" \
  -s /bin/sh www-data

Partie 2 : CLI go-passbolt

L’interface web est pratique pour le quotidien, mais elle ne suffit pas pour l’automatisation. Comment récupérer un mot de passe dans un script Bash ? Comment créer 50 credentials pour un nouveau projet ? Comment injecter un token API dans une pipeline CI/CD ?

C’est le rôle de la CLI go-passbolt-cli. Écrite en Go, elle fonctionne sur Linux, macOS et Windows. Elle communique avec l’API Passbolt et utilise votre clé GPG privée pour déchiffrer les secrets localement.

Ce que vous pouvez faire avec la CLI

Lister les ressources, dossiers, utilisateurs, groupes
Créer des mots de passe, dossiers, groupes
Récupérer un secret par son ID ou son nom
Partager une ressource avec un utilisateur ou un groupe
Exporter vers KeePass pour une sauvegarde locale
Injecter des secrets dans des variables d’environnement (commande exec)

La CLI supporte également le MFA (TOTP) pour les comptes protégés.

Installation de la CLI

# Télécharger et installer le paquet
VERSION="0.4.1"
wget https://github.com/passbolt/go-passbolt-cli/releases/download/v${VERSION}/go-passbolt-cli_${VERSION}_linux_amd64.deb
sudo dpkg -i go-passbolt-cli_${VERSION}_linux_amd64.deb

# Vérification
passbolt --version
# passbolt version 0.4.1

brew install passbolt/tap/go-passbolt-cli

VERSION="0.4.1"
OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed 's/x86_64/amd64/' | sed 's/aarch64/arm64/')

curl -LO "https://github.com/passbolt/go-passbolt-cli/releases/download/v${VERSION}/go-passbolt-cli_${VERSION}_${OS}_${ARCH}.tar.gz"
tar xzf go-passbolt-cli_${VERSION}_${OS}_${ARCH}.tar.gz
sudo mv passbolt /usr/local/bin/

go install github.com/passbolt/go-passbolt-cli@latest
# Note : le binaire s'appelle go-passbolt-cli

Configuration

Récupérez d’abord votre clé privée GPG depuis l’interface web : Profil → Inspecteur de clé → Privé → Copier.

Sauvegarder la clé privée

# Coller la clé privée dans un fichier
cat > ~/.passbolt-key.asc << 'EOF'
-----BEGIN PGP PRIVATE KEY BLOCK-----
[Votre clé privée]
-----END PGP PRIVATE KEY BLOCK-----
EOF

chmod 600 ~/.passbolt-key.asc

Configurer la CLI
Fenêtre de terminal
```
passbolt configure \
  --serverAddress https://passbolt.example.com \
  --userPrivateKeyFile ~/.passbolt-key.asc \
  --userPassword 'VotrePassphrase'
```
Si vous omettez --userPassword, la CLI vous la demandera à chaque commande. Plus sécurisé en production.

Vérifier la connexion

passbolt verify
# Server Verified and Saved

Commandes essentielles

La CLI suit une structure simple : passbolt <action> <entité> [options]. Les actions principales sont list, create, get, update, delete, share. Les entités sont resource (mot de passe), folder, user, group.

Voyons les commandes les plus utiles au quotidien.

Lister les ressources (mots de passe)

Première chose à faire après la configuration : vérifier que vous voyez bien vos secrets.

# Lister toutes les ressources
passbolt list resource

# Sortie :
# ID                                   | FolderParentID | Name       | Username        | URI
# 1a1dd36f-9ccf-45c6-822b-55d0d84d4a94 |                | GitLab     | admin           | https://gitlab.example.com
# 2b2ee47g-0dde-56d7-933c-66e1e95e5b95 |                | AWS Console| iam-admin       | https://console.aws.amazon.com

# Filtrer avec une expression CEL
passbolt list resource --filter 'Name == "GitLab"'

# Sortie JSON pour les scripts
passbolt list resource -j | jq '.[0].Name'

Créer une ressource

Pour stocker un nouveau secret, utilisez create resource. Les champs obligatoires sont --name et --password. Les autres (username, uri, description) sont optionnels mais recommandés pour retrouver facilement le secret plus tard.

Astuce : générez un mot de passe aléatoire directement avec openssl rand -base64 24.

# Créer un mot de passe
passbolt create resource \
  --name "Database Production" \
  --username "db_admin" \
  --password "$(openssl rand -base64 24)" \
  --uri "postgresql://db.example.com:5432" \
  --description "Accès admin PostgreSQL prod"

# Retourne l'ID de la ressource créée
# 3c3ff58h-1eef-67e8-044d-77f2f06f6c06

Récupérer un mot de passe

# Par ID
passbolt get resource --id 1a1dd36f-9ccf-45c6-822b-55d0d84d4a94

# Sortie :
# FolderParentID:
# Name: GitLab
# Username: admin
# URI: https://gitlab.example.com
# Password: zX3"#v)er(^z^=e_DC
# Description: Compte admin GitLab

# Récupérer uniquement le mot de passe (pour scripts)
passbolt get resource --id 1a1dd36f-... -j | jq -r '.Password'

Créer un dossier

passbolt create folder --name "Production"
# Retourne l'ID du dossier

# Créer une ressource dans ce dossier
passbolt create resource \
  --name "API Key Prod" \
  --password "sk_live_xxx" \
  --folderParentID <folder-id>

Partager une ressource

Le partage est la raison d’être de Passbolt. Par défaut, seul le créateur d’un secret peut le voir. Pour le rendre accessible à d’autres, vous devez explicitement le partager.

Passbolt propose quatre niveaux de permission, inspirés de la gestion des droits Unix :

Niveau	Signification	Cas d’usage
`1`	Lecture seule	L’utilisateur peut voir et copier le mot de passe, mais pas le modifier. Idéal pour partager un accès en lecture à un développeur.
`7`	Peut modifier	L’utilisateur peut changer le mot de passe. Pour les admins qui doivent effectuer des rotations.
`15`	Propriétaire	Contrôle total : modifier, supprimer, partager. Réservé aux responsables du secret.
`-1`	Supprimer	Retire la permission existante. Pratique pour révoquer un accès.

# Lister les utilisateurs
passbolt list user

# Partager avec un utilisateur
passbolt share resource \
  --id <resource-id> \
  --user <user-id> \
  --type 7

# Partager avec un groupe
passbolt share resource \
  --id <resource-id> \
  --group <group-id> \
  --type 1

Injecter des secrets dans l’environnement

C’est la fonctionnalité la plus puissante pour l’automatisation. Au lieu d’écrire des secrets en clair dans vos scripts ou fichiers .env, vous utilisez une référence passbolt://.

Quand vous exécutez passbolt exec, la CLI :

Scanne les variables d’environnement contenant passbolt://
Récupère et déchiffre les secrets correspondants
Injecte les valeurs réelles dans le processus enfant
Le processus parent (votre shell) ne voit jamais le secret en clair

# Définir une variable avec une référence Passbolt
export GITHUB_TOKEN=passbolt://3c3ff58h-1eef-67e8-044d-77f2f06f6c06

# Exécuter une commande avec le secret injecté
passbolt exec -- gh auth login

Le processus gh reçoit le vrai token, mais votre historique shell et vos logs ne contiennent que la référence passbolt://. Parfait pour les pipelines CI/CD.

Exporter vers KeePass

passbolt export keepass --file backup.kdbx
# Demande un mot de passe pour le fichier KeePass

Partie 3 : Intégration Ansible

La collection Ansible anatomicjc.passbolt utilise py-passbolt qui dépend de PGPy pour le déchiffrement GPG. Or, PGPy (v0.6.0) ne supporte pas les algorithmes SHA3 (IDs 12 et 14) définis dans le RFC 9580 OpenPGP.

Passbolt v5.x utilise la bibliothèque JavaScript openpgp.js qui génère des clés avec SHA3-256 ou SHA3-512 pour les signatures. Résultat : toute tentative de connexion échoue avec :

ValueError: 14 is not a valid HashAlgorithm

Pourquoi ce problème ? Le fichier constants.py de PGPy définit l’enum HashAlgorithm avec les valeurs MD5 (1), SHA1 (2), SHA256 (8), SHA384 (9), SHA512 (10) — mais pas SHA3-256 (12) ni SHA3-512 (14). C’est une limitation de la bibliothèque, pas de Passbolt.

Statut : En février 2026, aucune issue GitHub officielle ne propose de correctif. La CLI Go (go-passbolt-cli) fonctionne car elle utilise les bibliothèques crypto natives de Go qui supportent SHA3.

Solution : utiliser la CLI dans Ansible

En attendant une mise à jour de PGPy, vous pouvez appeler la CLI go-passbolt-cli depuis vos playbooks :

---
- hosts: all
  gather_facts: false
  vars:
    passbolt_resource_id: "26ebf995-0966-44e2-a162-aabe17169f43"

  tasks:
    - name: Récupérer le secret via CLI
      ansible.builtin.command:
        cmd: passbolt get resource --id {{ passbolt_resource_id }} --json
      register: passbolt_result
      changed_when: false
      no_log: true  # Ne pas logger le mot de passe

    - name: Parser le JSON
      ansible.builtin.set_fact:
        db_password: "{{ (passbolt_result.stdout | from_json).password }}"
      no_log: true

    - name: Utiliser le mot de passe
      ansible.builtin.debug:
        msg: "Connexion à la base de données..."
      # Remplacer par votre tâche réelle

Prérequis : La CLI doit être installée et configurée sur le contrôleur Ansible (passbolt configure).

Alternative : collection Ansible (si clé compatible)

Si vous utilisez une ancienne version de Passbolt ou une clé GPG générée avec un algorithme classique (SHA256/SHA512), la collection anatomicjc.passbolt fonctionne normalement.

Vous utilisez Ansible pour automatiser votre infrastructure. Vos playbooks ont besoin de mots de passe : accès aux bases de données, tokens API, clés SSH. Où les stocker ?

Les approches classiques ont des inconvénients :

Variables en clair dans l’inventaire — Dangereux si le dépôt Git est compromis
Ansible Vault — Sécurisé, mais les secrets sont dupliqués (Vault + système réel)
Variables d’environnement — Difficiles à gérer à grande échelle

L’intégration Passbolt offre le meilleur des deux mondes : les secrets restent dans Passbolt (source unique de vérité), et Ansible les récupère au moment de l’exécution via un plugin lookup.

La collection anatomicjc.passbolt, développée par la communauté, s’installe en une commande et s’utilise comme n’importe quel lookup Ansible.

Installation

# Installer la collection Ansible
ansible-galaxy collection install anatomicjc.passbolt

# Installer le module Python
pip install py-passbolt

Configuration

Créez un fichier de configuration Ansible :

[defaults]
inventory = inventory
vault_identity_list = main@vault_pass

Chiffrez vos credentials avec Ansible Vault :

# Créer le fichier de mot de passe vault
echo "VotreMotDePasseVault" > vault_pass
chmod 600 vault_pass

# Chiffrer la clé privée
cat ~/.passbolt-key.asc | ansible-vault encrypt_string --stdin-name 'private_key_vault'

# Chiffrer la passphrase
echo -n 'VotrePassphrase' | ansible-vault encrypt_string --stdin-name 'passphrase_vault'

Inventaire avec secrets chiffrés

all:
  vars:
    private_key_vault: !vault |
      $ANSIBLE_VAULT;1.2;AES256;main
      39636534343934636630663262623366653836646264386462663731363366...

    passphrase_vault: !vault |
      $ANSIBLE_VAULT;1.2;AES256;main
      61366163363437623364613637386463333965363130383664393135313263...

  hosts:
    localhost:
      ansible_connection: local

Exemple de playbook

---
- hosts: all
  gather_facts: false
  environment:
    PASSBOLT_BASE_URL: "https://passbolt.example.com"
    PASSBOLT_PRIVATE_KEY: "{{ private_key_vault }}"
    PASSBOLT_PASSPHRASE: "{{ passphrase_vault }}"

  tasks:
    - name: Récupérer les credentials GitLab
      ansible.builtin.set_fact:
        gitlab_creds: "{{ lookup('anatomicjc.passbolt.passbolt', 'GitLab') }}"

    - name: Afficher le username (debug)
      ansible.builtin.debug:
        msg: "Username: {{ gitlab_creds.username }}"

    - name: Utiliser le mot de passe
      ansible.builtin.uri:
        url: "https://gitlab.example.com/api/v4/user"
        headers:
          PRIVATE-TOKEN: "{{ gitlab_creds.password }}"
      register: gitlab_user

    - name: Récupérer uniquement le mot de passe
      ansible.builtin.debug:
        var: lookup('anatomicjc.passbolt.passbolt', 'Database Production').password

Exécution :

ansible-playbook playbook.yml

Partie 3bis : Intégration Terraform

Terraform peut utiliser Passbolt comme source de secrets. Deux cas d’usage :

Lire un secret — Data source passbolt_password pour récupérer un credential existant
Créer un secret — Resource passbolt_password pour provisionner des credentials automatiquement

Installation du provider

terraform {
  required_providers {
    passbolt = {
      source  = "Bald1nh0/passbolt"
      version = "~> 1.3.0"
    }
  }
}

provider "passbolt" {
  base_url    = "https://passbolt.example.com/"
  private_key = file("~/.passbolt-key.asc")
  passphrase  = var.passbolt_passphrase
}

variable "passbolt_passphrase" {
  type      = string
  sensitive = true
}

Récupérer un secret existant

Utilisez la data source passbolt_password pour lire un secret par son UUID. Vous pouvez récupérer l’UUID depuis l’interface web (clic droit sur une ressource → Copier le lien).

# Récupérer un secret par son ID
data "passbolt_password" "db_prod" {
  id = "1a1dd36f-9ccf-45c6-822b-55d0d84d4a94"
}

# Utiliser le secret dans une ressource
resource "aws_db_instance" "main" {
  identifier     = "app-db"
  engine         = "postgres"
  instance_class = "db.t3.micro"

  username = data.passbolt_password.db_prod.username
  password = data.passbolt_password.db_prod.password
}

# Afficher (pour debug uniquement)
output "db_username" {
  value = data.passbolt_password.db_prod.username
}

output "db_password" {
  value     = data.passbolt_password.db_prod.password
  sensitive = true
}

Créer un secret

Provisionner un nouveau secret dans Passbolt, par exemple pour un nouveau service :

# Récupérer le groupe DevOps pour le partage
data "passbolt_group" "devops" {
  name = "DevOps"
}

# Créer un nouveau secret
resource "passbolt_password" "api_token" {
  name          = "API Token Production"
  description   = "Token généré par Terraform pour l'API interne"
  username      = "api-service"
  password      = random_password.api_token.result
  uri           = "https://api.example.com"
  folder_parent = "Production"

  # Partager avec l'équipe DevOps (lecture seule)
  share_groups = [data.passbolt_group.devops.id]
}

resource "random_password" "api_token" {
  length  = 32
  special = true
}

Bonnes pratiques

Pratique	Raison
Stocker la passphrase dans une variable d’environnement	`export TF_VAR_passbolt_passphrase="..."` — Pas dans le code
Utiliser un compte technique dédié	Créer un utilisateur Passbolt avec accès limité aux secrets nécessaires
Ne pas exposer les outputs sensibles	Toujours `sensitive = true` pour les mots de passe
Versionner les UUIDs, pas les secrets	Les IDs Passbolt peuvent être commités, pas les valeurs

Partie 4 : Fonctionnalités avancées (v5.x)

Passbolt v5.x (avril 2025 et après) a introduit des fonctionnalités importantes. Si vous utilisez une version récente, voici ce que vous pouvez exploiter.

Secret History (v5.7+)

Vous avez déjà écrasé un mot de passe par erreur ? Avec l’historique des secrets, ce n’est plus un drame.

Passbolt conserve les versions précédentes de chaque secret. Depuis l’interface web, vous pouvez consulter l’historique et restaurer une ancienne version en un clic. C’est aussi utile pour comprendre quand et pourquoi un mot de passe a changé — pratique en cas d’incident.

Encrypted Metadata Zero-Knowledge (v5.5+)

Par défaut, Passbolt peut accéder à la clé de métadonnées partagée pour faciliter l’onboarding des nouveaux utilisateurs. C’est pratique, mais cela signifie que le serveur a techniquement accès aux noms et descriptions des secrets (pas aux mots de passe eux-mêmes, qui sont chiffrés avec votre clé GPG personnelle).

Le mode Zero-Knowledge va plus loin : le serveur n’a jamais accès à la clé de métadonnées. Conséquence : quand un nouvel utilisateur rejoint l’équipe, un administrateur doit lui transmettre manuellement la clé. Plus contraignant, mais plus sûr pour les environnements très sensibles.

Dynamic Roles (v5.8+, Pro)

Dans les versions antérieures, Passbolt avait deux rôles fixes : Admin et User. C’est simple, mais parfois trop rigide.

Les rôles dynamiques permettent de créer des rôles intermédiaires. Par exemple, vous pouvez autoriser certains utilisateurs à créer des groupes sans leur donner tous les droits d’administration. Ou déléguer la gestion des demandes de récupération de compte à un responsable RH.

Cette fonctionnalité est disponible uniquement dans l’édition Pro.

Standalone Notes (v5.6+)

Jusqu’à la v5.5, chaque entrée Passbolt était un “mot de passe” avec un champ username et password. Mais que faire pour stocker une clé SSH, un certificat TLS, ou une documentation sensible ?

Les notes autonomes répondent à ce besoin. Vous pouvez créer une entrée contenant uniquement du texte (jusqu’à 50 Ko), sans champ username ni password. Elle bénéficie du même chiffrement et des mêmes permissions que les mots de passe classiques.

Cas d’usage :

Clés SSH privées
Certificats et clés PEM
Documentation de procédures sensibles (plans de reprise, contacts d’urgence)
Notes de configuration pour des environnements spécifiques

Dépannage

Passbolt est globalement stable, mais certains problèmes reviennent régulièrement. Voici les erreurs les plus fréquentes et comment les résoudre.

Symptôme	Cause probable	Solution
`FAIL: A valid JWT key pair is missing`	Clés JWT non générées	`cake passbolt create_jwt_keys`
`SSL certificate problem: self-signed`	Certificat auto-signé	Configurer Let’s Encrypt ou `--tlsSkipVerify` (lab)
`Could not verify server`	Première connexion	Exécuter `passbolt verify` une fois
`Connection refused`	Conteneurs non démarrés	`docker compose ps` puis `up -d`
`Authentication failed`	Mauvaise passphrase ou clé	Vérifier le contenu de `--userPrivateKeyFile`
`Resource not found`	ID incorrect ou pas d’accès	Vérifier avec `passbolt list resource`
Healthcheck rouge sur NTP	Horloge non synchronisée	Configurer NTP sur l’hôte Docker
`14 is not a valid HashAlgorithm` (Python)	PGPy ne supporte pas SHA3 (Passbolt v5.x)	Utiliser la CLI go-passbolt, voir Partie 3

Healthcheck complet

docker compose -f docker-compose-ce.yaml exec passbolt su -m -c \
  "/usr/share/php/passbolt/bin/cake passbolt healthcheck" \
  -s /bin/sh www-data

À retenir

Chiffrement GPG de bout en bout — Le serveur ne voit jamais les mots de passe en clair
CLI complète — Automatisation avec go-passbolt-cli (create, list, get, share, exec) ✅ testé
Terraform fonctionnel — Provider Bald1nh0/passbolt v1.3.0 ✅ testé
Ansible limité — PGPy ne supporte pas SHA3, utiliser la CLI en workaround
Partage granulaire — Utilisateurs, groupes, niveaux de permission (lecture, modification, propriétaire)
Made in Europe — Éditeur au Luxembourg, audité par Cure53
Version épinglée — Toujours utiliser une version spécifique, jamais latest
Sauvegarde — Volumes Docker (gpg, jwt, database) + kit de récupération utilisateur

Prochaines étapes

HashiCorp Vault Gestionnaire de secrets pour infrastructure et applications

SOPS Chiffrer les fichiers de configuration dans Git

Sealed Secrets Secrets chiffrés pour Kubernetes et GitOps