Coffre cryptomator archlinux nextcloud

Coffre cryptomator archlinux nextcloud

Notes

Chirpy post 2026-10-20-Coffre_Cryptomator_ArchLinux.md publié le 20 octobre 2026 à 10h15mn

Cryptomator est un logiciel libre à code source ouvert de chiffrement à la volée multi-plateformes développé par la société allemande Skymatic GmbH depuis 2016, et publié selon les termes de la licence publique générale GNU (Source wikipédia FR)

Cryptomator GUI

Installer l’application cryptomator

1

yay -S cryptomator-bin

Dans Cryptomator Desktop :

  • cliquez sur Ajouter un coffre ;
  • choisissez Créer un nouveau coffre ;
  • placez-le dans le dossier synchronisé, par exemple :
1

$HOME/.coffre-cryptomator/Prive.cryptomator
  • définissez une phrase de passe longue, unique et différente de votre mot de passe Nextcloud ;
  • choisissez le mécanisme de montage recommandé par Cryptomator pour votre système ;
  • déverrouillez le coffre : il apparaîtra comme un disque ou un dossier virtuel.

Création volume chiffré yann-crypto

Le disque virtuel contient la version déchiffrée. C’est uniquement là que vous devez créer, lire et modifier vos documents. Cryptomator chiffre les opérations à la volée avant que Nextcloud les synchronise.

Déverrouillage coffre

Ouvir le coffre avec l’application Cryptomator, en cliquant sur Déverrouiller

Mot de passe de 20 caractères

Emplacement coffre déverrouillé

Créer un emplacement pour le coffre déverrouillé /home/yann/.local/share/Cryptomator/mnt/yann-crypto/

Sauvegarde du coffre fermé

Sauvegarder le coffre fermé, c’est-à-dire le dossier chiffré ~/.coffre-cryptomator/yann-crypto, et jamais le point de montage ~/.local/share/Cryptomator/mnt/yann-crypto. Ce dernier montreles fichiers en clair : si Nextcloud ou un autre outil le synchronise, tes données se retrouvent non chiffrées sur le serveur, ce qui annule l’intérêt du coffre. Le dossier chiffré, lui, est conçu pour être copié ou synchronisé tel quel.

Ce qu’il faut sauvegarder

  • Tout le dossier yann-crypto, qui contient vault.cryptomator, masterkey.cryptomator et le dossier d/. Sans les fichiers de clé, le reste est inutilisable.
  • Le mot de passe et, mieux, la clé de récupération (Cryptomator → Options du coffre → Clé de récupération). Garde-la hors de l’ordinateur et hors du coffre lui-même, par exemple dans KeePassXC ou sur papier. Sans mot de passe ni clé de récupération, aucune sauvegarde ne sert à rien.

Clé de récupération

cryptomator-cli ne sait pas afficher la clé de récupération. Il ne propose que unlock et list-mounters (à ma connaissance pour la 0.6.2 ; cryptomator-cli --help te le confirmera). Cette clé se consulte uniquement dans l’application graphique.

Afficher la clé de récupération

  1. Arrête d’abord le service, pour que le CLI et l’appli graphique n’utilisent pas le coffre en même temps :

    1

     systemctl --user stop cryptomator-vault.service
  2. Ouvre l’application graphique cryptomator. Si le coffre yann-crypto n’y figure pas, ajoute-le via + → Ajouter un coffre existant, en choisissant le dossier ~/.coffre-cryptomator/yann-crypto (celui qui contient vault.cryptomator).
  3. Sélectionne le coffre (verrouillé), puis Options du coffre → Clé de récupération → Afficher la clé de récupération.
  4. Saisis le mot de passe du coffre : la clé s’affiche sous forme d’une suite de mots.
  5. Copie-la et range-la hors du coffre et hors de l’ordinateur : dans KeePassXC (dans une base distincte de celle qui dépend du coffre) et idéalement sur papier.

  6. Referme la fenêtre, quitte l’application, puis relance le service :

    1

     systemctl --user start cryptomator-vault.service

‼️IMPORTANT‼️

  • Cette clé de récupération donne un accès complet au coffre, y compris la possibilité de réinitialiser le mot de passe : traite-la comme le mot de passe lui-même, et ne la stocke pas en clair dans un dossier synchronisé avec Nextcloud ou sauvegardé avec le coffre.
  • Elle sert dans le cas où l’on perd le mot de passe ou que masterkey.cryptomator est endommagé : dans l’application, Ajouter un coffre existant puis Restaurer l’accès (ou « J’ai oublié mon mot de passe ») permet de définir un nouveau mot de passe. Tu n’en as donc besoin qu’en cas de souci, mais elle doit être notée dès maintenant.
  • Une fois le mot de passe réinitialisé par ce biais, pense à mettre à jour l’entrée KWallet : secret-tool store --label="Cryptomator Coffre yann" application cryptomator vault monCoffre.

Initialisation dépôt borg yann-crypto

  • Storage Box: bx11-yann-02
  • PassPhrase: dware -n 8 |tee $HOME/sharenfs/pc1/.borg/yann-crypto.passphrase
  • Exclusions: touch /home/yann/.borg/yann-crypto.exclusions (A remplir, une exclusion par ligne)
  • Dépôt cryptomator: ssh://u694796@u694796.your-storagebox.de:23/./yann-crypto

Initialisation dépôt yann-crypto

1
2
3
4

export BORG_PASSPHRASE="`cat /home/yann/.borg/yann-crypto.passphrase`"
export BORG_RSH='ssh -i /home/yann/.ssh/bx11-yann-02'
BORG_REPOSITORY='ssh://u694796@u694796.your-storagebox.de:23/./yann-crypto'
borg init --encryption=repokey-blake2 $BORG_REPOSITORY

Cryptomator CLI

Coffre, déverrouillage et verrouillage automatiques avec la session KDE

Contexte : Arch Linux, KDE Plasma, cryptomator-cli 0.6.2, mot de passe dans KWallet, service systemd utilisateur, Linger=yes.

Prérequis

1

sudo pacman -S fuse3 libsecret

Vérification de KWallet (Secret Service) :

1
2

busctl --user status org.freedesktop.secrets | grep Comm   # doit afficher ksecretd (ou kwalletd6)
grep -r kwallet /etc/pam.d/                                 # ouverture auto à la connexion (kwallet-pam)

Le mot de passe du portefeuille doit être identique à celui de la session.

Installer cryptomator-cli (sans Maven)

Télécharger l’archive Linux x64 de la dernière release (0.6.2) sur https://github.com/cryptomator/cli/releases, la décompresser, puis rendre le binaire accessible en ~/.local/bin/cryptomator-cli.(en mode su sudo -s)

1
2
3
4
5

cd /opt
wget https://github.com/cryptomator/cli/releases/download/0.6.2/cryptomator-cli-0.6.2-linux-x64.zip
unzip cryptomator-cli-0.6.2-linux-x64.zip
ln -s /opt/cryptomator-cli/bin/cryptomator-cli /home/yano/.local/bin/cryptomator-cli
exit

Contrôles :

1
2

~/.local/bin/cryptomator-cli --help
~/.local/bin/cryptomator-cli list-mounters   # doit lister LinuxFuseMountProvider

Enregistrer le mot de passe du coffre dans KWallet

1
2
3

secret-tool store --label="Cryptomator Coffre yann" application cryptomator vault monCoffre
# saisir le mot de passe du coffre (invite « Password: »)
secret-tool lookup application cryptomator vault monCoffre | wc -c   # contrôle de la longueur (20 dnas mon cas)

Les attributs application cryptomator vault monCoffre doivent être identiques dans le script de déverrouillage.

Service utilisateur cryptomator-vault

Créer le service utilisateur ~/.config/systemd/user/cryptomator-vault.service

1
2
3
4
5
6
7
8
9
10
11
12

[Unit]
Wants=coffre-rsync.service
After=graphical-session.target coffre-borg.service
PartOf=graphical-session.target

[Service]
ExecStart=%h/.local/bin/cryptomator-unlock.sh
ExecStopPost=-/usr/bin/fusermount3 -uz %h/.local/share/Cryptomator/mnt/yann-crypto
TimeoutStopSec=20

[Install]
WantedBy=graphical-session.target

1
2

systemctl --user daemon-reload
systemctl --user enable --now cryptomator-vault.service

PartOf=graphical-session.target est indispensable ici : avec Linger=yes (nécessaire pour d’autres services utilisateur), systemd n’arrête pas les services à la déconnexion. C’est cette cible, arrêtée avec la session graphique, qui verrouille le coffre.

Script déverrouillage cryptomator-unlock.sh

Les dossiers

  • Le dossier du coffre: $HOME/.coffre-cryptomator/
    • Coffre chiffrée: yann-crypto
  • Point de montage coffre déchiffrée: $HOME/.local/share/Cryptomator/mnt/yann-crypto

Script de déverrouillage ~/.local/bin/cryptomator-unlock.sh (chmod +x)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/bin/bash
set -e
VAULT="$HOME/.coffre-cryptomator/yann-crypto"
MNT="$HOME/.local/share/Cryptomator/mnt/yann-crypto"
CLI="$HOME/.local/bin/cryptomator-cli"

[ -x "$CLI" ]   || { echo "cryptomator-cli introuvable : $CLI" >&2; exit 1; }
[ -d "$VAULT" ] || { echo "Coffre introuvable : $VAULT" >&2; exit 1; }
mkdir -p "$MNT"

# Attendre le trousseau (jusqu'à 60 s)
pw=""
for _ in $(seq 1 30); do
    pw=$(secret-tool lookup application cryptomator vault monCoffre 2>/dev/null || true)
    [ -n "$pw" ] && break
    sleep 2
done
[ -n "$pw" ] || { echo "Mot de passe introuvable dans le trousseau" >&2; exit 1; }

exec "$CLI" unlock \
  --password:stdin \
  --mounter=org.cryptomator.frontend.fuse.mount.LinuxFuseMountProvider \
  --mountPoint="$MNT" \
  "$VAULT" <<<"$pw"

Coffre Cryptomator partagé via Nextcloud

Synthèse : du partage Nextcloud aux services systemd utilisateur, entre plusieurs machines (PC de bureau, portables), sous Arch / CachyOS avec KDE Plasma.

Principe

  • Un coffre Cryptomator est un dossier de fichiers chiffrés. On synchronise ce dossier, jamais le point de montage en clair.
  • Un seul compte Nextcloud, un seul coffre.
  • Pas de dossier commun : tout ce qui n’est pas réservé à une machine est commun.
  • Un seul fichier .zones, à la racine du coffre, donc synchronisé et identique sur toutes les machines. Une ligne par machine : le nom d’hôte puis, après les deux-points, les dossiers ou fichiers de la racine du coffre qui ne concernent que cette machine, séparés par des virgules.
  • Chaque machine retrouve sa ligne grâce à son nom d’hôte. Ses entrées sont les siennes ; les entrées des autres lignes lui sont interdites ; le reste est commun.
1
2
3
4
5
6
7
8

Coffre/
├── .zones        ← liste synchronisée : machine → entrées réservées
├── sauvegardes/  ← réservé à pc1
├── bureau2/      ← réservé à pc2
├── portable/     ← réservé à e6230
├── Documents/    ┐
├── Photos/       ├ commun : modifié sur une seule machine à la fois
└── notes.md      ┘
  • Chemins identiques sur chaque machine :
    • dossier chiffré : ~/.coffre-cryptomator (synchronisé avec Nextcloud)
    • point de montage : ~/.local/share/Cryptomator/mnt/yann-crypto (jamais synchronisé)
  • Synchronisation avec nextcloudcmd (pas de client graphique), pilotée par des services systemd utilisateur.
  • Scripts et unités identiques sur toutes les machines. Seul ~/.config/coffre/coffre.conf varie (Borg et dossiers à copier).

Ordre des opérations

1
2

Ouverture : coffre-sync → coffre-borg → cryptomator-vault → coffre-rsync
Fermeture : coffre-rsync → cryptomator-vault → coffre-borg → coffre-sync

À la fermeture : contrôle des entrées interdites et copie rsync dans le coffre ouvert, démontage, sauvegarde Borg du dossier chiffré figé (si activée sur la machine), puis envoi vers Nextcloud.

Le fichier .zones

Format : nom_d_hote: entrée1, entrée2, …. Les lignes vides, les espaces autour des virgules et les commentaires (#) sont ignorés. Exemple :

1
2
3
4
5
6

# machine: dossiers/fichiers réservés (à la racine du coffre)
# La première entrée est la zone où écrit le rsync de la machine.
pc1: sauvegardes
pc2: bureau2
e6230: portable
portable2: portable2

Règles de lecture, pour la machine qui lit :

Catégorie Définition
Siennes entrées de sa propre ligne
Interdites entrées des autres lignes, sauf si elles figurent aussi dans sa ligne
Communes tout le reste, y compris .zones lui-même
  • Une entrée peut figurer sur plusieurs lignes (un dossier partagé entre deux machines précises) : elle est alors « sienne » pour chacune.
  • La première entrée de la ligne d’une machine est la zone où son rsync copie ses dossiers.
  • Un nom d’hôte absent du fichier : le rsync est annulé (voir section 8).
  • Le nom d’hôte se vérifie avec echo $HOSTNAME. Il doit être unique et stable ; en cas de renommage, mettre à jour .zones.
  • Un nom contenant une virgule ou un deux-points n’est pas géré.
  • Format JSON possible à la place (avec jq), mais la saisie à la main est moins pratique ; le format texte n’a aucune dépendance.

Machines

Exemple (à adapter) :

Machine (nom d’hôte) BORG Ligne dans .zones
pc1 (bureau) oui pc1: sauvegardes
pc2 (bureau 2) non pc2: bureau2
e6230 (portable) non e6230: portable
portable2 (portable 2) non portable2: portable2

BORG=oui uniquement sur la ou les machines qui sauvegardent le dossier chiffré.

Serveur Nextcloud ,création dossier coffre-cryptomator

  1. Créer un mot de passe d’application (Paramètres → Sécurité → Créer un nouveau mot de passe d’application). Obligatoire avec le 2FA et WebAuthn. Un par machine est préférable : il peut être révoqué séparément.
  2. Créer le dossier distant coffre-cryptomator sur le serveur (interface web).
  3. Laisser activés le versionnage et la corbeille.
  4. Ne pas activer le chiffrement de bout en bout Nextcloud sur ce dossier (doublon avec Cryptomator).
  5. Ne pas utiliser le client graphique Nextcloud sur ce dossier.

Installation sur chaque machine (nextcloud-client,.netrc,coffre.conf et .zones)

Client nextcloud

1

sudo pacman -S nextcloud-client      # fournit nextcloudcmd

Le déverrouillage exige aussi une installation complète de Cryptomator et de cryptomator-cli, identique à celle de pc1 (version graphique, puis CLI). Le lanceur cryptomator-cli copié seul dans ~/.local/bin s’arrête sans aucun message (code 1), car il lui manque le Java embarqué et ses bibliothèques. Vérification sur la nouvelle machine : cryptomator-cli --version doit afficher une version.

Identifiants (mot de passe d’application) ~/.netrc :

1
2
3
4

cat > ~/.netrc <<'EOF'
machine cloud.rnmkcy.eu login TON_UTILISATEUR password MOT_DE_PASSE_APPLICATION
EOF
chmod 600 ~/.netrc

~/.config/coffre/coffre.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

mkdir -p ~/.config/coffre
cat > ~/.config/coffre/coffre.conf <<'EOF'
# Sauvegarde Borg du dossier chiffré à la fermeture : oui / non
BORG="oui"

LOCAL="$HOME/.coffre-cryptomator"
MOUNT="$HOME/.local/share/Cryptomator/mnt/yann-crypto"
NC_URL="https://cloud.rnmkcy.eu"
NC_REMOTE="/coffre-cryptomator"

# Dossiers copiés par rsync dans la zone de cette machine
SOURCES=("$HOME/sharenfs/pc1/.borg" "$HOME/.keepassx" "$HOME/.ssh")

# Facultatif : forcer le nom de machine (par défaut, le nom d'hôte)
#MACHINE="pc1"
EOF

Première synchronisation (à la main, une seule fois)

  1. Première machine (celle qui possède déjà le coffre) :

    1

     nextcloudcmd -n --path /coffre-cryptomator ~/.coffre-cryptomator https://cloud.rnmkcy.eu
  2. Attendre la fin de l’envoi.

  3. Chaque autre machine : créer le dossier local vide, puis récupérer le coffre :

    1
2

     mkdir -p ~/.coffre-cryptomator
 nextcloudcmd -n --path /coffre-cryptomator ~/.coffre-cryptomator https://cloud.rnmkcy.eu
  4. Sur chaque autre machine, configurer cryptomator-cli comme sur la première (mot de passe du coffre dans KWallet, service cryptomator-vault).

Création de .zones (une seule fois, coffre monté, depuis une seule machine)

1
2
3
4
5
6
7

cat > ~/.local/share/Cryptomator/mnt/yann-crypto/.zones <<'EOF'
# machine: dossiers/fichiers réservés (à la racine du coffre)
# La première entrée est la zone où écrit le rsync de la machine.
pc1: sauvegardes
pc2: bureau2
e6230: portable
EOF

Laisser la synchro se terminer avant d’utiliser le coffre sur une autre machine.

Scripts (~/.local/bin/ et ~/.local/lib/coffre/, identiques partout)

~/.local/lib/coffre/zones.sh (bibliothèque, à sourcer)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

mkdir -p ~/.local/lib/coffre
cat > ~/.local/lib/coffre/zones.sh <<'EOF'
# Lecture de .zones. À sourcer après coffre.conf.
MACHINE="${MACHINE:-${HOSTNAME%%.*}}"

trim() {
    local s="$1"
    s="${s#"${s%%[![:space:]]*}"}"
    s="${s%"${s##*[![:space:]]}"}"
    printf '%s' "$s"
}

# lire_zones <fichier> <machine>
# Renseigne : TROUVE (0/1), MES[] (entrées de la machine), INTERDITS[]
lire_zones() {
    local fichier="$1" moi="$2" ligne nom it e
    local -a items AUTRES
    MES=(); AUTRES=(); INTERDITS=(); TROUVE=0

    while IFS= read -r ligne || [ -n "$ligne" ]; do
        ligne="${ligne%%#*}"
        [[ "$ligne" == *:* ]] || continue
        nom="$(trim "${ligne%%:*}")"
        [ "$nom" = "$moi" ] && TROUVE=1
        IFS=',' read -ra items <<< "${ligne#*:}"
        for it in "${items[@]}"; do
            it="$(trim "$it")"
            [ -n "$it" ] || continue
            if [ "$nom" = "$moi" ]; then MES+=("$it"); else AUTRES+=("$it"); fi
        done
    done < "$fichier"

    # Interdites : entrées des autres machines, sauf celles qui sont aussi les siennes
    for e in "${AUTRES[@]}"; do
        printf '%s\n' "${MES[@]}" | grep -qxF -- "$e" && continue
        printf '%s\n' "${INTERDITS[@]}" | grep -qxF -- "$e" && continue
        INTERDITS+=("$e")
    done
}
EOF

~/.local/bin/coffre-sync

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#!/usr/bin/env bash
set -u
source "$HOME/.config/coffre/coffre.conf"

exec 9>"${XDG_RUNTIME_DIR}/coffre-sync.lock"
flock -n 9 || { echo "synchro déjà en cours"; exit 0; }

notif() {
    echo "$1"
    # Bureau déjà fermé : pas de notification (notify-send attendrait jusqu'à 60 s)
    pgrep -u "$UID" -x plasmashell >/dev/null 2>&1 || return 0
    timeout 3 notify-send -a "Coffre" "Coffre" "$1" 2>/dev/null || true
}

# À la fermeture, ne jamais synchroniser tant que le coffre est monté
if [ "${1:-}" = "fin" ] && mountpoint -q "$MOUNT"; then
    notif "Coffre encore monté : synchro annulée"
    exit 1
fi

# Machine nomade : serveur injoignable = on continue sans erreur
if ! curl -fsS -m 5 -o /dev/null "$NC_URL/status.php"; then
    notif "Nextcloud injoignable : synchro ignorée"
    exit 0
fi

notif "Synchronisation Nextcloud…"
if nextcloudcmd --silent -n --path "$NC_REMOTE" "$LOCAL" "$NC_URL"; then
    notif "Synchronisation terminée"
else
    notif "Échec de la synchronisation Nextcloud"
    exit 0
fi

~/.local/bin/coffre-rsync

debut pose un repère horaire une fois le coffre monté. fin contrôle les entrées interdites, puis copie dans la zone de cette machine (première entrée de sa ligne).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#!/usr/bin/env bash
set -u
source "$HOME/.config/coffre/coffre.conf"
source "$HOME/.local/lib/coffre/zones.sh"

STAMP="${XDG_RUNTIME_DIR}/coffre-rsync.stamp"
LISTE="$MOUNT/.zones"

notif() {
    echo "$1"
    # Bureau déjà fermé : pas de notification (notify-send attendrait jusqu'à 60 s)
    pgrep -u "$UID" -x plasmashell >/dev/null 2>&1 || return 0
    timeout 3 notify-send -a "Coffre" "Coffre" "$1" 2>/dev/null || true
}

case "${1:-}" in
    debut) touch "$STAMP"; exit 0 ;;
    fin) ;;
    *) echo "usage : $0 debut|fin"; exit 2 ;;
esac

# Ne jamais écrire dans un point de montage vide
if ! mountpoint -q "$MOUNT"; then
    notif "Coffre non monté : rsync annulé"
    exit 1
fi

if [ ! -f "$LISTE" ]; then
    notif "Fichier .zones introuvable dans le coffre : rsync annulé"
    exit 1
fi

lire_zones "$LISTE" "$MACHINE"
if [ "$TROUVE" -ne 1 ] || [ "${#MES[@]}" -eq 0 ]; then
    notif "Machine « $MACHINE » sans entrée dans .zones : rsync annulé"
    exit 1
fi
DEST="${MES[0]}"

# Garde : modification locale d'une entrée interdite pendant la session
if [ -f "$STAMP" ]; then
    for z in "${INTERDITS[@]}"; do
        [ -e "$MOUNT/$z" ] || continue
        if [ -n "$(find "$MOUNT/$z" -newer "$STAMP" -print -quit 2>/dev/null)" ]; then
            notif "Attention : modification locale dans « $z »"
        fi
    done
fi

notif "Copie des dossiers dans « $DEST »…"
mkdir -p "$MOUNT/$DEST"
for src in "${SOURCES[@]}"; do
    rsync -rt "$src" "$MOUNT/$DEST/" || notif "Échec rsync : $src"
done
sync
notif "Copie terminée"

-rt (et non -a) comme dans le script d’origine : le point de montage FUSE n’accepte pas la conservation des droits et des propriétaires. Sans --delete : un fichier supprimé à la source reste dans le coffre. Le contrôle des zones est un avertissement : rien n’est bloqué.

Sauvegarde borg coffre chiffré, script ~/.local/bin/coffre-borg
Reprise de cryptomator-borg.sh (dépôt, clé SSH, exclusions, nom d’archive, rétention, compact, codes de retour inchangés), avec deux ajouts : le test BORG de coffre.conf et le refus de sauvegarder si le coffre est encore monté.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#!/bin/bash
source "$HOME/.config/coffre/coffre.conf"

# Machine sans sauvegarde Borg : rien à faire
[ "${BORG:-non}" = "oui" ] || exit 0

export BORG_PASSPHRASE="$(cat /home/yann/.borg/yann-crypto.passphrase)"
export BORG_RSH='ssh -i /home/yann/.ssh/bx11-yann-02'
BORG_PATH="/home/yann/.coffre-cryptomator/yann-crypto"
BORG_EXCLUSION="/home/yann/.borg/yann-crypto.exclusions"
BORG_REPOSITORY=ssh://u694796@u694796.your-storagebox.de:23/./yann-crypto
BACKUP_DATE=$(date +%Y-%m-%d-%Hh%M)

notif() {
    pgrep -u "$UID" -x plasmashell >/dev/null 2>&1 || return 0
    timeout 3 notify-send -a "Coffre" -i drive-harddisk "Sauvegarde Borg" "$1" 2>/dev/null
}

# Une seule sauvegarde à la fois
exec 9>"/run/user/$UID/coffre-borg.lock"
flock -n 9 || exit 0

# Le coffre doit être démonté : on sauvegarde le dossier chiffré figé
if mountpoint -q "$MOUNT"; then
  notif "Coffre encore monté : sauvegarde annulée"
  echo "Coffre encore monté : sauvegarde annulée"
  exit 1
fi

notif "Sauvegarde du coffre en cours…"

borg create -v --stats --exclude-from "$BORG_EXCLUSION" \
  "${BORG_REPOSITORY}::${BACKUP_DATE}" "$BORG_PATH"
rc=$?

if [ $rc -le 1 ]; then
  borg prune -v --stats --keep-daily=7 --keep-weekly=1 --keep-monthly=1 "$BORG_REPOSITORY"
  borg compact "$BORG_REPOSITORY"
  msg="Sauvegarde Borg terminée"
  [ $rc -eq 1 ] && msg="Sauvegarde Borg terminée avec avertissements"
else
  msg="Sauvegarde Borg en ERREUR (code $rc)"
fi

notif "$msg"
echo "$msg"
exit $rc

Rendre les scripts exécutables :

1

chmod +x ~/.local/bin/coffre-sync ~/.local/bin/coffre-rsync ~/.local/bin/coffre-borg

cryptomator-unlock.sh (attente du trousseau, erreurs explicites)

Au démarrage de la session, le trousseau (KWallet) peut ne pas être prêt, ou le secret peut être absent : l’ancien script s’arrêtait alors avec le code 1 sans rien écrire dans le journal. Version complète, qui attend jusqu’à 60 s et signale chaque cause d’échec :

~/.local/bin/cryptomator-unlock.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#!/bin/bash
set -e
VAULT="$HOME/.coffre-cryptomator/yann-crypto"
MNT="$HOME/.local/share/Cryptomator/mnt/yann-crypto"
CLI="$HOME/.local/bin/cryptomator-cli"

[ -x "$CLI" ]   || { echo "cryptomator-cli introuvable : $CLI" >&2; exit 1; }
[ -d "$VAULT" ] || { echo "Coffre introuvable : $VAULT" >&2; exit 1; }
mkdir -p "$MNT"

# Attendre le trousseau (jusqu'à 60 s)
pw=""
for _ in $(seq 1 30); do
    pw=$(secret-tool lookup application cryptomator vault monCoffre 2>/dev/null || true)
    [ -n "$pw" ] && break
    sleep 2
done
[ -n "$pw" ] || { echo "Mot de passe introuvable dans le trousseau" >&2; exit 1; }

exec "$CLI" unlock \
  --password:stdin \
  --mounter=org.cryptomator.frontend.fuse.mount.LinuxFuseMountProvider \
  --mountPoint="$MNT" \
  "$VAULT" <<<"$pw"

Sur une nouvelle machine, enregistrer d’abord le mot de passe du coffre dans le trousseau, depuis une session graphique ouverte (la commande le demande de façon interactive) :

1

secret-tool store --label="Cryptomator monCoffre" application cryptomator vault monCoffre

Unités systemd utilisateur (~/.config/systemd/user/, identiques partout)

~/.config/systemd/user/coffre-sync.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[Unit]
Description=Synchronisation Nextcloud du coffre chiffré
PartOf=graphical-session.target
After=graphical-session.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=%h/.local/bin/coffre-sync debut
ExecStop=%h/.local/bin/coffre-sync fin
TimeoutStopSec=300

[Install]
WantedBy=graphical-session.target

Sauvegarde borg coffre chiffré, service ~/.config/systemd/user/coffre-borg.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[Unit]
Description=Sauvegarde Borg du coffre chiffré (à la fermeture)
PartOf=graphical-session.target
After=graphical-session.target
Wants=coffre-sync.service
After=coffre-sync.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/bin/true
ExecStop=%h/.local/bin/coffre-borg
TimeoutStopSec=1800

[Install]
WantedBy=graphical-session.target

~/.config/systemd/user/coffre-rsync.service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[Unit]
Description=Copie rsync vers le coffre ouvert (à la fermeture)
PartOf=graphical-session.target
After=graphical-session.target
Requires=cryptomator-vault.service
After=cryptomator-vault.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=%h/.local/bin/coffre-rsync debut
ExecStop=%h/.local/bin/coffre-rsync fin
TimeoutStopSec=300

[Install]
WantedBy=graphical-session.target

Drop-in du service existant cryptomator-vault

1

systemctl --user edit cryptomator-vault

1
2
3
4
5
6

[Unit]
Wants=coffre-borg.service coffre-rsync.service
After=coffre-borg.service

[Service]
SuccessExitStatus=143

coffre-borg s’exécute sur toutes les machines mais ne fait rien si BORG n’est pas à oui ; l’ordre de la chaîne reste le même partout. SuccessExitStatus=143 évite que l’arrêt normal du coffre (SIGTERM) soit journalisé comme un échec.

1
2
3
4
5
6
7
8
9
10
11
12
13

# /home/yann/.config/systemd/user/cryptomator-vault.service
[Unit]
Wants=coffre-rsync.service
After=graphical-session.target coffre-borg.service
PartOf=graphical-session.target

[Service]
ExecStart=%h/.local/bin/cryptomator-unlock.sh
ExecStopPost=-/usr/bin/fusermount3 -uz %h/.local/share/Cryptomator/mnt/yann-crypto
TimeoutStopSec=20

[Install]
WantedBy=graphical-session.target

Hook de fermeture de session KDE (~/.config/plasma-workspace/shutdown/10-coffre.sh)
Avec le linger activé, le gestionnaire utilisateur survit à la déconnexion : l’arrêt des services ne doit pas dépendre uniquement de graphical-session.target. Le script de fermeture de Plasma qui existe déjà devient un simple déclencheur de la chaîne :

~/.config/plasma-workspace/shutdown/10-coffre.sh

1
2

#!/bin/sh
systemctl --user stop coffre-rsync.service cryptomator-vault.service coffre-borg.service coffre-sync.service

systemd arrête ces unités dans l’ordre des dépendances : rsync, démontage, Borg, Nextcloud. La fermeture de session dure le temps de la chaîne (Borg avec prune et compact peut prendre plusieurs minutes). Pour ne pas attendre, remplacer par systemctl --user --no-block stop … : la chaîne continue alors en arrière-plan, mais un arrêt complet de la machine peut l’interrompre.

Sauvegarde borg coffre chiffré. Place-la en dernier, après le verrouillage du coffre : tu sauvegardes ainsi le dossier chiffré dans un état stable, sans écriture en cours, et il contient déjà les données que la synchronisation rsync vient d’y déposer. L’ordre devient donc : rsync → arrêt du service (verrouillage) → Borg.

Script Borg ~/.local/bin/cryptomator-borg.sh (chmod +x)

Le script, avec quelques ajustements : verrou contre les exécutions simultanées, notifications, --progress retiré (inutile hors terminal) et code retour traité.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#!/bin/bash
export BORG_PASSPHRASE="$(cat /home/yann/.borg/yann-crypto.passphrase)"
export BORG_RSH='ssh -i /home/yann/.ssh/bx11-yann-02'
BORG_PATH="/home/yann/.coffre-cryptomator/yann-crypto"
BORG_EXCLUSION="/home/yann/.borg/yann-crypto.exclusions"
BORG_REPOSITORY=ssh://u694796@u694796.your-storagebox.de:23/./yann-crypto
BACKUP_DATE=$(date +%Y-%m-%d-%Hh%M)

# Une seule sauvegarde à la fois
exec 9>"/run/user/$UID/cryptomator-borg.lock"
flock -n 9 || exit 0

notify-send -a "Coffre" -i drive-harddisk "Sauvegarde Borg" "Sauvegarde du coffre en cours…" 2>/dev/null

borg create -v --stats --exclude-from "$BORG_EXCLUSION" \
  "${BORG_REPOSITORY}::${BACKUP_DATE}" "$BORG_PATH"
rc=$?

if [ $rc -le 1 ]; then
  borg prune -v --stats --keep-daily=7 --keep-weekly=1 --keep-monthly=1 "$BORG_REPOSITORY"
  borg compact "$BORG_REPOSITORY"
  msg="Sauvegarde Borg terminée"
  [ $rc -eq 1 ] && msg="Sauvegarde Borg terminée avec avertissements"
else
  msg="Sauvegarde Borg en ERREUR (code $rc)"
fi

notify-send -a "Coffre" -i drive-harddisk "Sauvegarde Borg" "$msg" 2>/dev/null
echo "$msg"
exit $rc

Activation et test

1
2
3
4
5
6
7
8
9
10
11
12

systemctl --user daemon-reload
systemctl --user enable coffre-sync coffre-borg coffre-rsync
systemctl --user restart cryptomator-vault

# Attendre le montage du coffre (quelques secondes)
sleep 10
mountpoint ~/.local/share/Cryptomator/mnt/yann-crypto
systemctl --user is-active coffre-rsync        # doit répondre « active »

# Test de la fermeture : même commande que le hook KDE
systemctl --user stop coffre-rsync.service cryptomator-vault.service coffre-borg.service coffre-sync.service
journalctl --user -u coffre-rsync -u cryptomator-vault -u coffre-borg -u coffre-sync --since "-5min" --no-pager

Ne pas enchaîner restart et stop sans attendre : un stop reçu pendant le démarrage de coffre-rsync l’interrompt (journal : « killed, status=15/TERM ») et son ExecStop ne s’exécute alors jamais, donc aucune copie n’est faite.

Puis faire une vraie fermeture de session, rouvrir une session et vérifier l’ordre avec :

1

journalctl --user -u coffre-rsync -u cryptomator-vault -u coffre-borg -u coffre-sync --since "-15min" --no-pager

Avec le linger, le gestionnaire utilisateur reste actif d’une session à l’autre : ne pas utiliser -b -1, qui désigne le démarrage précédent de la machine. Le test du coffre doit se faire dans une vraie session graphique (trousseau KWallet déverrouillé) : sans elle, secret-tool ne trouve pas le mot de passe et le déverrouillage échoue.

Ajouter une machine

  1. Installer nextcloud-client, créer ~/.netrc et le mot de passe d’application.
  2. Créer ~/.config/coffre/coffre.conf (BORG="non" en général) et la bibliothèque zones.sh.
  3. Depuis n’importe quelle machine avec le coffre monté, ajouter une ligne dans ~/.local/share/Cryptomator/mnt/yann-crypto/.zones (par exemple portable2: portable2) et laisser la synchro se terminer. Les autres machines la reçoivent à leur prochaine synchro.
  4. Première synchro (section 6), cryptomator-cli, scripts et unités (sections 7 et 8).

Précautions

  • Ne jamais synchroniser ~/.local/share/Cryptomator/mnt/yann-crypto (contenu en clair).
  • Le contrôle est un avertissement, pas un blocage. Cryptomator ne permet pas d’interdire l’écriture ; la notification apparaît à la fermeture de session si une entrée interdite a été modifiée localement.
  • .zones fait partie de la partie commune : le modifier depuis une seule machine à la fois, et attendre la fin de la synchro avant de changer de machine.
  • Une machine absente de .zones n’a pas de rsync : le script s’arrête avec une notification plutôt que de créer un dossier au hasard. Un nom d’hôte mal écrit dans .zones est donc détecté dès la première fermeture.
  • Une faute de frappe dans une entrée (par exemple burau) crée un dossier mal nommé à la racine du coffre, traité comme commun. Vérifier les noms lors de la création.
  • Nouvelle machine pas encore synchronisée : tant que sa ligne n’a pas été reçue par les autres, elles considèrent sa zone comme commune et ne la contrôlent pas.
  • Notifications à la fermeture : une fois le bureau fermé, notify-send attend jusqu’à 60 s qu’un service de notification apparaisse. Chaque appel bloquait la fin de session, et une reconnexion trop rapide échouait en boucle (journal : « Transaction for plasma-workspace-wayland.target/start is destructive … stop job queued », puis plantage de ksplashqml). Les fonctions notif() ne notifient donc que si plasmashell tourne, avec un timeout. Tant que la chaîne de fermeture dure (Borg avec prune et compact peut être long), attendre la fin avant de se reconnecter.
  • Cycle d’ordre au démarrage : les quatre unités du coffre doivent toutes avoir After=graphical-session.target. Sans cela, systemd ajoute lui-même « la cible démarre après ces unités », ce qui crée un cycle avec coffre-sync (qui, lui, démarre après la cible). Il supprime alors une unité du démarrage (journal : « Found ordering cycle… Job … deleted ») et la chaîne n’est plus dans l’ordre. Vérification : systemd-analyze --user verify graphical-session.target ne doit afficher aucun cycle.
  • Contrôle mountpoint : les scripts rsync et Borg s’y appuient, ne pas le retirer.
  • Fichiers *conflicted copy* dans le coffre : ne pas les supprimer à la main, comparer avant de décider. Le versionnage Nextcloud et Borg sont les filets de sécurité.
  • Délai à l’extinction : si la fermeture dure plus de 2 minutes environ, augmenter TimeoutStopSec de user@.service ou lancer Borg hors fermeture de session.
  • Le fichier caché .sync_*.db créé par nextcloudcmd dans ~/.coffre-cryptomator est normal et n’est pas envoyé au serveur.

Ordre conseillé :

  1. Installer coffre.conf, zones.sh, les trois scripts, les trois unités et le drop-in, sans activer.
  2. Créer .zones dans le coffre monté avec la ligne pc1: sauvegardes.
  3. Renommer les anciens scripts en .bak, remplacer le contenu de 10-coffre.sh.
  4. daemon-reload, enable, test par la séquence de la section 9, puis une vraie fermeture de session.
  5. Vérifier qu’aucun timer ni tâche cron n’appelle encore cryptomator-borg.sh (systemctl --user list-timers, crontab -l), sinon la sauvegarde s’exécuterait deux fois.
  6. Supprimer les .bak une fois le résultat validé dans le journal.