Audit de mots de passe avec KeePassXC : guide technique avancé

Audit de mots de passe avec KeePassXC : guide technique avancé

Ce guide couvre l'audit en profondeur d'une base KeePassXC : analyse de la robustesse des mots de passe, détection de fuites via HIBP, exploitation de keepassxc-cli pour l'automatisation, et durcissement des paramètres de chiffrement. On suppose que vous avez déjà une base .kdbx avec des entrées.

Pré-requis

• KeePassXC 2.7.12 ou supérieur (mars 2026)
• Accès terminal (bash/zsh)
• Optionnel : Python 3.10+ pour les scripts d'audit avancés
• Optionnel : YubiKey pour le second facteur

Installation depuis les sources ou les dépôts

Ubuntu/Debian (PPA officiel pour la dernière version)

## Ajouter le PPA officiel KeePassXC
sudo add-apt-repository ppa:phoerber/keepassxc
sudo apt update
sudo apt install keepassxc -y

## Vérifier la version installée
keepassxc-cli —version

Fedora

sudo dnf install keepassxc -y

Arch Linux

sudo pacman -S keepassxc

macOS (Homebrew)

brew install —cask keepassxc

Vérification de l'intégrité du téléchargement

Si vous téléchargez manuellement depuis keepassxc.org, vérifiez la signature GPG :

## Importer la clé publique KeePassXC
gpg —keyserver keys.openpgp.org —recv-keys BF5A669F2272CF4324C1FDA8CFB4C2166397D0D2

## Vérifier la signature du fichier téléchargé
gpg —verify KeePassXC-2.7.12-x86_64.AppImage.sig KeePassXC-2.7.12-x86_64.AppImage

Vous devez obtenir Good signature from "KeePassXC Release Signing Key". Si ce n'est pas le cas, ne lancez pas le binaire.

Utilisation de keepassxc-cli

Le vrai pouvoir de KeePassXC pour l'audit, c'est son outil en ligne de commande.

Lister toutes les entrées d'une base

## Lister les entrées du groupe racine
keepassxc-cli ls ~/passwords.kdbx

## Lister récursivement toutes les entrées de tous les groupes
keepassxc-cli ls -R ~/passwords.kdbx

L'outil demande le mot de passe maître à chaque invocation. Pour automatiser, on verra plus loin comment le passer via stdin.

Afficher les détails d'une entrée

## Voir le mot de passe d'une entrée spécifique
keepassxc-cli show -s ~/passwords.kdbx "Réseaux sociaux/Twitter"

## Voir uniquement le mot de passe (utile pour le piping)
keepassxc-cli show -s -a password ~/passwords.kdbx "Email/ProtonMail"

Estimer la force d'un mot de passe

## Estimer l'entropie d'un mot de passe
keepassxc-cli estimate "MonSuperMotDePasse42!"

La sortie donne l'entropie en bits. Visez au minimum 60 bits, idéalement 80+.

Audit via l'interface graphique

Rapports de santé

Dans KeePassXC, allez dans Base de données → Rapports de base de données.

Trois onglets essentiels :

1. Santé des mots de passe : classe chaque entrée par score de robustesse. Le score est basé sur l'entropie (longueur, complexité, patterns détectés).

1. HIBP (Have I Been Pwned) : vérifie chaque mot de passe contre la base de données HIBP via le protocole k-Anonymity. Seuls les 5 premiers caractères du hash SHA-1 sont envoyés au serveur, le reste de la comparaison se fait en local.

1. Statistiques : vue d'ensemble de la base (nombre d'entrées, groupes, entrées expirées, entrées sans mot de passe).

Audit HIBP en ligne de commande

Pour les bases volumineuses ou l'automatisation, on peut scripter la vérification HIBP.

Script d'audit complet

#!/bin/bash
## audit-keepassxc.sh — Audit HIBP des mots de passe d'une base KeePassXC
## Usage: ./audit-keepassxc.sh /chemin/vers/base.kdbx

set -euo pipefail

DB_PATH="${1:?Usage: $0 /chemin/vers/base.kdbx}"
RESULT_FILE="/tmp/keepassxc-audit-$(date +%Y%m%d-%H%M%S).txt"
COMPROMISED=0
TOTAL=0

## Vérifier que la base existe
if [[ ! -f "$DB_PATH" ]]; then
    echo "Erreur : fichier $DB_PATH introuvable."
    exit 1
fi

echo "Entrez le mot de passe maître :"
read -s MASTER_PW
echo

## Récupérer toutes les entrées
ENTRIES=$(echo "$MASTER_PW" | keepassxc-cli ls -R -f "$DB_PATH" 2>/dev/null | grep -v '/$')

echo "=== Audit HIBP — $(date) ===" > "$RESULT_FILE"
echo "Base : $DB_PATH" >> "$RESULT_FILE"
echo "" >> "$RESULT_FILE"

while IFS= read -r entry; do
    [[ -z "$entry" ]] && continue
    TOTAL=$((TOTAL + 1))

    # Extraire le mot de passe
    PW=$(echo "$MASTER_PW" | keepassxc-cli show -s -a password "$DB_PATH" "$entry" 2>/dev/null)
    [[ -z "$PW" ]] && continue

    # Calculer le hash SHA-1
    HASH=$(echo -n "$PW" | sha1sum | awk '{print toupper($1)}')
    PREFIX="${HASH:0:5}"
    SUFFIX="${HASH:5}"

    # Interroger l'API HIBP (k-Anonymity)
    RESPONSE=$(curl -s "https://api.pwnedpasswords.com/range/$PREFIX")

    # Chercher notre suffixe dans la réponse
    COUNT=$(echo "$RESPONSE" | grep -i "$SUFFIX" | cut -d: -f2 | tr -d '\r' || echo "0")

    if [[ "$COUNT" -gt 0 ]]; then
        COMPROMISED=$((COMPROMISED + 1))
        echo "[COMPROMIS] $entry — trouvé $COUNT fois dans des fuites" | tee -a "$RESULT_FILE"
    fi

    # Respecter le rate limit de l'API (1 requête/1.5s max)
    sleep 1.5
done <<< "$ENTRIES"

echo "" >> "$RESULT_FILE"
echo "=== Résumé ==="  | tee -a "$RESULT_FILE"
echo "Total analysé : $TOTAL" | tee -a "$RESULT_FILE"
echo "Compromis : $COMPROMISED" | tee -a "$RESULT_FILE"
echo "Rapport sauvé : $RESULT_FILE"

## Nettoyage mémoire
unset MASTER_PW PW HASH

Rendez le script exécutable et lancez-le :

chmod +x audit-keepassxc.sh
./audit-keepassxc.sh ~/passwords.kdbx

Détection des doublons en CLI

Repérer les mots de passe réutilisés via un script :

#!/bin/bash
## detect-duplicates.sh — Trouve les mots de passe réutilisés
## Usage: ./detect-duplicates.sh /chemin/vers/base.kdbx

set -euo pipefail

DB_PATH="${1:?Usage: $0 /chemin/vers/base.kdbx}"

echo "Mot de passe maître :"
read -s MASTER_PW
echo

declare -A HASH_MAP

ENTRIES=$(echo "$MASTER_PW" | keepassxc-cli ls -R -f "$DB_PATH" 2>/dev/null | grep -v '/$')

while IFS= read -r entry; do
    [[ -z "$entry" ]] && continue
    PW=$(echo "$MASTER_PW" | keepassxc-cli show -s -a password "$DB_PATH" "$entry" 2>/dev/null)
    [[ -z "$PW" ]] && continue

    HASH=$(echo -n "$PW" | sha256sum | awk '{print $1}')

    if [[ -n "${HASH_MAP[$HASH]:-}" ]]; then
        echo "[DOUBLON] \"$entry\" utilise le même mot de passe que \"${HASH_MAP[$HASH]}\""
    else
        HASH_MAP[$HASH]="$entry"
    fi
done <<< "$ENTRIES"

unset MASTER_PW PW HASH

Durcissement de la base de données

Par défaut, KeePassXC utilise AES-256 avec Argon2d. On peut renforcer les paramètres.

Passer à Argon2id

Argon2id est résistant aux attaques par canal auxiliaire (side-channel) contrairement à Argon2d.

1. Base de données → Paramètres de la base de données → Sécurité
2. Changez l'algorithme de dérivation de clé en Argon2id
3. Paramètres recommandés :

• Itérations : 10 ou plus
• Mémoire : 256 Mo minimum (512 Mo si la machine le permet)
• Parallélisme : nombre de cœurs CPU (généralement 4 ou 8)

1. Cliquez sur « Benchmark 1 seconde » pour calibrer automatiquement

L'objectif : que le déchiffrement prenne environ 1 seconde sur votre machine. C'est imperceptible pour vous, mais ça rend le brute-force quasi impossible.

Ajouter un fichier-clé

Un fichier-clé ajoute un second facteur : même avec votre mot de passe, impossible d'ouvrir la base sans ce fichier.

## Générer un fichier-clé aléatoire de 256 bits
dd if=/dev/urandom of=~/keepassxc-keyfile.key bs=32 count=1 2>/dev/null
chmod 400 ~/keepassxc-keyfile.key

Dans KeePassXC : Base de données → Paramètres → Sécurité → Protection supplémentaire → Ajouter un fichier-clé.

Stockez ce fichier-clé sur une clé USB dédiée, séparée de votre base .kdbx. Si les deux sont au même endroit, le second facteur ne sert à rien.

YubiKey comme second facteur

KeePassXC supporte nativement les YubiKey via le Challenge-Response (slot 2).

1. Configurez votre YubiKey avec le Yubico Personalization Tool : Challenge-Response HMAC-SHA1 sur le slot 2
2. Dans KeePassXC : Base de données → Paramètres → Sécurité → Protection supplémentaire → Ajouter un Challenge-Response
3. Branchez la YubiKey et validez

Désormais, l'ouverture de la base nécessite le mot de passe maître ET la YubiKey physique branchée.

Verrouillage automatique

Dans Outils → Paramètres → Sécurité :

• Verrouiller après 5 minutes d'inactivité (ou moins)
• Verrouiller quand l'écran se verrouille
• Verrouiller quand la session change
• Effacer le presse-papiers après 10 secondes

Génération de mots de passe en CLI

## Générer un mot de passe de 24 caractères (majuscules, minuscules, chiffres, spéciaux)
keepassxc-cli generate -L 24 -lUns

## Générer une passphrase de 6 mots
keepassxc-cli diceware -W 6

## Générer et ajouter directement une entrée
echo "$MASTER_PW" | keepassxc-cli add ~/passwords.kdbx \
  -u "user@example.com" \
  —url "https://service.example.com" \
  -g -L 24 \
  "Services/NouveauService"

Automatisation de l'audit

Pour lancer un audit régulier via cron :

## Éditer la crontab
crontab -e

## Ajouter une vérification mensuelle le premier dimanche à 3h du matin
0 3 1-7 * 0 /chemin/vers/audit-keepassxc.sh /chemin/vers/passwords.kdbx >> /var/log/keepassxc-audit.log 2>&1

Pour l'exécution automatique, vous devrez stocker le mot de passe maître de manière sécurisée (secret manager, variable d'environnement protégée, ou keyring système). Ce n'est recommandé que sur un serveur sécurisé, pas sur un poste de travail partagé.

Export et migration

Exporter vers un autre format

## Export en CSV (attention : mots de passe en clair)
echo "$MASTER_PW" | keepassxc-cli export —format csv ~/passwords.kdbx > export.csv

## Export en XML KDBX (pour importer dans un autre KeePassXC)
echo "$MASTER_PW" | keepassxc-cli export —format xml ~/passwords.kdbx > export.xml

Supprimez ces fichiers immédiatement après utilisation :

## Suppression sécurisée
shred -vfz -n 5 export.csv
rm export.csv

Dépannage

| Problème | Cause probable | Solution |

|—-|—-|—-|

| Error while reading the database: Invalid credentials | Mot de passe incorrect ou fichier-clé manquant | Vérifiez le mot de passe. Si fichier-clé configuré, pointez vers le bon fichier. |

| Database is locked by another process | Autre instance de KeePassXC ouverte | Fermez toutes les instances. Si nécessaire : killall keepassxc |

| L'extension navigateur ne se connecte pas | Port natif non configuré | Vérifiez que l'intégration navigateur est activée dans Paramètres → Intégration. Redémarrez le navigateur. |

| HIBP renvoie des erreurs réseau | API indisponible ou rate limit atteint | Attendez quelques minutes. L'API tolère environ 1 requête/1.5s. |

| keepassxc-cli: command not found | CLI non dans le PATH | Sous Linux, vérifiez le paquet. Sous macOS : le CLI est dans /Applications/KeePassXC.app/Contents/MacOS/keepassxc-cli |

| La base se verrouille trop vite | Paramètre de verrouillage agressif | Ajustez dans Outils → Paramètres → Sécurité. 5 minutes est un bon compromis. |

| Import CSV échoue | Format de colonnes incorrect | Vérifiez l'encodage UTF-8 et la correspondance des colonnes dans l'assistant d'import. |

| Argon2id rend l'ouverture trop lente | Paramètres de mémoire/itérations trop élevés | Relancez le benchmark. Visez 1s de déchiffrement, pas 5. |

Bonnes pratiques récapitulatives

• Mots de passe uniques partout, 20 caractères minimum ou passphrase 5+ mots
• Chiffrement Argon2id avec au moins 256 Mo de mémoire
• Second facteur (fichier-clé ou YubiKey) pour la base principale
• Sauvegarde .kdbx chiffrée sur au moins 2 supports physiques distincts
• Audit HIBP trimestriel
• Presse-papiers effacé en 10 secondes maximum
• Export CSV interdit sauf migration ponctuelle, et détruit immédiatement après

—-

Ressources :

• Documentation officielle : https://keepassxc.org/docs/
• Code source : https://github.com/keepassxreboot/keepassxc
• API Have I Been Pwned : https://haveibeenpwned.com/API/v3
• Argon2 : https://www.rfc-editor.org/rfc/rfc9106