Backup in die Cloud: Unterschied zwischen den Versionen

Aus Neobikers Wiki
Zur Navigation springen Zur Suche springen
Zeile 64: Zeile 64:


Wie sieht die Lösung aus?
Wie sieht die Lösung aus?
* Der Cloud-Speicher wird per SSH oder WebDav eingebunden
* Der '''Cloud-Speicher''' wird per SSH oder WebDav eingebunden
* Die individuellen Daten-Verzeichnisse werden (temporär) in einem Backup-Verzeichnis gebündelt (ReadOnly)
* Die individuellen Daten-Verzeichnisse werden (temporär) in einem '''Backup-Verzeichnis''' gebündelt (ReadOnly)
* Das Backup-Verzeichnis wird verschlüsselt
* Das Backup-Verzeichnis wird ''GoCryptFS -reverse'' '''verschlüsselt'''
* Das verschlüsselte Verzeichnis wird mit rsync in den Cloud-Speicher synchronisiert
* Das verschlüsselte Backup-Verzeichnis wird mit rsync in den Cloud-Speicher '''synchronisiert'''


Der Mount-Befehl stellt mittels der Optionen –bind und -ro sämtliche Daten-Verzeichnisse in einem Backup-Verzeichnis zusammen. Gocryptfs verschlüsselt dieses Verzeichnis mit der Option –reverse. Rsync kopiert schließlich sämtliche Dateien direkt in den Cloud-Speicher (-e ssh), oder in das per WebDav eingebundene Cloud-Verzeichnis.
Der Mount-Befehl stellt mittels der Optionen –bind und -ro sämtliche Daten-Verzeichnisse in einem Backup-Verzeichnis zusammen. Gocryptfs verschlüsselt dieses Verzeichnis mit der Option –reverse. Rsync kopiert schließlich sämtliche Dateien direkt in den Cloud-Speicher (-e ssh), oder in das per WebDav eingebundene Cloud-Verzeichnis.

Version vom 5. Dezember 2020, 22:00 Uhr

Verteilt? aber sicher!

Eines ist sicher, meine Daten sind sicher. So sicher, dass ich genau dann, wenn ich sie brauche, eventuell keinen Zugriff darauf habe:

  • Im Urlaub im Ausland, wenn meine Papiere gestohlen wurden.
  • Ein Stromausfall, der meinen Server außer Gefecht setzt, er nicht mehr fehlerfrei startet und ich keinen Zugriff auf den Fileserver mehr bekomme.
  • Oder noch schlimmer: ein Unglück Zuhause wie Feuer oder Hochwasser, das meinen Server zerstört.
  • Denkbar ist auch, dass Daten aus Versehen gelöscht wurden, was vielleicht noch nicht einmal bemerkt wurde.

Für letzteren Fall läuft auf meinem Fileserver drei Mal täglich ein Skript, welches ein Snapshot Backup erzeugt, ohne wirklich viel Platz zu benötigen: Das allseits bekannte „rsync“ – das Schweizer Taschenmesser unter Sync- bzw. Kopierprogrammen – ist in der Lage, per Hardlink Kopien im Filesystem anzulegen, welchen keinen zusätzlichen Speicherplatz belegen. Es gibt natürlich viele Programme die Backups erzeugen können, aber ein stabiles selbstgeschriebenes Skript hat für mich immer noch einen gewissen Vorteil: Es funktioniert, überall. Ohne dass ein Programm-Update daran eventuell rumpfuscht, es nicht mehr unterstützt wird, eine neue Version ein Upgrade oder sogar eine Migration erfordern würde.

Verschlüsseltes Backup mit GoCryptFS

Dieser Artikel ist zugegebenermaßen entstanden, weil ich mein seit Jahr(zehnt)en installiertes System einer längst überfälligen Generalüberholung unterzog. Zur Verschlüsselung meiner persönlichen Daten kam bisher EncFS zum Einsatz, welches 2014 in einem Audit einige Sicherheitslücken offenbarte, von denen einige immer noch nicht behoben sind (https://vgough.github.io/encfs/). Meine Recherche nach einer Alternative führte mich zu gocryptfs (https://github.com/rfjakob/gocryptfs-website).

Gocryptfs auf der anderen Seite hielt (bisher) einem 2-Tages Audit stand. EncFS und gocryptfs verwenden das gleiche Konzept – ein virtuell ver- / entschlüsseltes Dateisystem wird durch einen Mount-Befehl in das Dateisystem eingehängt. Beide bieten eine „-reverse“ Option, welche (unverschlüsselte) Daten online in verschlüsselter Form in einem Dateisystem zur Verfügung stellt. Diese Option ist prädestiniert für das verschlüsselte Backup von Dateien, welche individuell und nur Bedarfsorientiert gesichert werden sollen.

Ein früherer Defekt einer nagelneuen 4TB Disk innerhalb der Garantie zog aufgrund des Hardware-Fehlers einen zwei Wochen dauernden Löschvorgang der Disk nach sich - wegen der Garantie musste ich die Disk ja zurücksenden und konnte sie nicht einfach vernichten. In Kombination mit den Sicherheitsbedenken des Einsatzes von EncFS für Backup-Szenarien in Cloud-Speicher ist demzufolge die transparente Vollverschlüsselung aller Daten auf den Festplatten mitels LUKS und der Einsatz von gocryptfs naheliegend.

LUKS und GoCryptFS

Mein altes Backup-Skript kopierte die bisher mittels EncFS im Dateisystem verschlüsselten Dateien 1:1 in die Cloud. Mit der LUKS Vollverschlüsselung der Festplatte oder dessen Partitionen stehen aber keine verschlüsselten Daten zum Kopieren mehr zur Verfügung - im Dateisystem selbst liegen sie ja wiederum entschlüsselt vor. Gocryptfs erzeugt mit der Option -reverse ein virtuelles Filesystem, welches die Daten online verschlüsselt ins Filesystem einbindet, ohne diese erneut auf der Festplatte zu speichern.

Verschlüsseln ohne Passwortabfrage

Das Passwort zum Ver- und Entschlüsseln der Disks/Partitionen sollte nicht auf der zu verschlüsselnden Festplatte selbst gespeichert werden. Damit der Server bei einem Reboot trotzdem ohne Passwortabfrage automatisch hochfährt, wird das Passwort z.B. von einem USB-Stick gelesen. Dieses kann in einer Datei oder auch versteckt in den ersten ungenutzten Blocks eines Devices außerhalb des Dateisystems gespeichert sein. Da in meinem Boot-Vorgang das Netzwerk schon zur Verfügung steht, wenn die Dateisysteme mit den User-Daten eingehängt werden, lese ich das Passwort per SSH von einem anderen Server oder Gerät ein, sodass der USB-Stick selbst nicht auf meinem Backup-Server erreichbar ist.

Datensicherheit

Folgende Aspekte sind jetzt also berücksichtigt:

  • Mehrfache tägliche Datensicherung schützt vor versehentlichem Löschen
  • Vollverschlüsselung schützt persönliche Daten auf den Festplatten
  • Passwörter zum Entschlüsseln der Festplatten sind auf unabhängiges System bzw. Device wie USB-Sticks ausgelagert
  • Backup der Daten liegt verschlüsselt in der Cloud vor
  • Disaster Recovery ist von überall mit einem beliebigen PC möglich, der meinen Live-USB Stick mit MX-Linux bootet

Cloud Backup

Wenden wir uns dem Thema Cloud-Backup zu. Wir haben alle erzwungenermaßen bereits Accounts bei mehreren Cloud-Providern wie z.B Google, Microsoft, T-Online um nur einige zu nennen. Viele bieten auch mehr oder weniger kostenlosen oder zusätzlichen Cloud-Speicher an, der selten Verwendung findet. Warum sollten wir also diesen allzeit und weltweit zur Verfügung stehenden Datenspeicher nicht dafür nutzen, unsere wichtigen Daten dort verschlüsselt abzuspeichern? Dem steht die durch dezentrale Zersplitterung entstehende Aufwand zur Beherrschung des zugrundeliegenden Datenchaos entgegen. Doch dem kann abgeholfen werden.

Idee ist, dass wir die vorhandenen unterschiedlichen Cloud-Speicher für ein Backup der wichtigen persönlichen Daten nutzen. Dieser lässt ich normalerweise über Protokolle wie webdav oder SSH/SFTP auf dem eigenen Rechner einbinden. Zur Synchronisierung der Daten in die Cloud kommt rsync zum Einsatz. Entweder in Kombination mit SSH, oder per webdav werden die Daten per gocryptfs verschlüsselt und in die Cloud kopiert.

Die benötigten Tools hierfür stehen alle als kostenlose Standard-Tools zur Verfügung: webdav, ssh, shell-skript, du, mount, find, rsync und gocryptfs.

Um die in der Cloud verschlüsselten Daten bei Bedarf wieder zu lesen, werden diese per webdav oder sshfs auf einem Rechner gemountet und anschließend mittels gocryptfs wieder entschlüsselt in das lokale Dateisystem eingebunden. Das kann sogar auf einem Live-Linux und damit auch auf einem USB-Stick erfolgen, den ich am Schlüsselbund immer parat habe.

GoCryptFS

Gocryptfs ist einfach zu benutzen. Man verschlüsselt ein vorhandenes Verzeichnis SourceDir wie folgt:

$ mkdir Encrypted
$ gocryptfs -reverse -init -config ConfigFile SourceDir
$ gocryptfs -reverse -config ConfigFile SourceDir Encrypted

Im Encrypted Verzeichnis sind jetzt alle Daten aus SourceDir verschlüsselt abgebildet, eine Änderung der verschlüsselten Dateien selbst ist nicht möglich (Encrypted ist als Abbild von SourceDir nur ReadOnly).

Die Dateien aus Encrypted können entschlüsselt werden mit:

$ mkdir Decrypted
$ gocryptfs -config ConfigFile Encrypted Decrypted

Die Daten stehen jetzt wieder entschlüsselt im Verzeichnis Decrypted zur Verfügung.

Struktur, der natürliche Feind von Chaos

Trivial ist anders: Verteile individuelle Verzeichnisse von unterschiedlichen Stellen zu unterschiedlichen Cloud-Anbietern.

KISS – „Keep it small and simple“ hilft auch hier, Ordnung ins vermeintliche Chaos zu bringen, und die angestrebte Usability und Stabilität der Lösung herzustellen.

Lösung

Wie sieht die Lösung aus?

  • Der Cloud-Speicher wird per SSH oder WebDav eingebunden
  • Die individuellen Daten-Verzeichnisse werden (temporär) in einem Backup-Verzeichnis gebündelt (ReadOnly)
  • Das Backup-Verzeichnis wird GoCryptFS -reverse verschlüsselt
  • Das verschlüsselte Backup-Verzeichnis wird mit rsync in den Cloud-Speicher synchronisiert

Der Mount-Befehl stellt mittels der Optionen –bind und -ro sämtliche Daten-Verzeichnisse in einem Backup-Verzeichnis zusammen. Gocryptfs verschlüsselt dieses Verzeichnis mit der Option –reverse. Rsync kopiert schließlich sämtliche Dateien direkt in den Cloud-Speicher (-e ssh), oder in das per WebDav eingebundene Cloud-Verzeichnis.

Normalerweise sind die persönlichen Daten aller Nutzer eines Servers über mehrere Verzeichnisse verstreut. Außerdem müssen nur einige Verzeichnisse in die Cloud gesichert werden. Eine einfache Konfiguration für ein zentrales CryptFS-Backup-Cloud Skript bildet die Grundlage für Usability und Stabilität (robust und wartungsarm) der Lösung. Da nur Standard-Protokolle und Programme verwendet werden, ist die Lösung extrem portabel und kann z.B. auf einem Rasperry, einem Linux-SAT-Receiver und anderen vorhandenen Devices implementiert werden.

Die Cloud-Backup Konfiguration muss folgende Informationen verknüpfen:

  1. Cloud-Speicher mit zugehörigem Account
  2. lokale Datenverzeichnisse der Benutzer

Für jeden Anwender bzw. dessen Accounts bei Cloud-Anbietern wird definiert, welche Verzeichnisse in dessen Cloud-Speicher synchronisiert werden sollen.

That’s it – sounds easy, is easy – and rock stable!

Konfiguration

Die individuellen Konfigurationen sind in sehr einfachen (Shell-) Skripten z.B. unter /etc/cryptfs-backup-cloud hinterlegt.

Konfiguration der Backup-Verzeichnisse, hier am Beosipel MagentaCloud von t-online für Benutzer neobiker:

$ mkdir /etc/cryptfs-backup-cloud
$ cat > /etc/cryptfs-backup-cloud/t-online_neobiker <<EOF
#!/bin/sh
# my cryptfs-backup-cloud script
# rsync an encrypted filesystem to cloud storage
[ -z "$RSYNC_CRYPT" ] && RSYNC_CRYPT=/usr/local/sbin/rsync-gocryptfs-cloud
# -----------------------------------------------
provider=t-online                        # provider name
WEBDAV=https://webdav.magentacloud.de/   # URL of provider cloud storage
SSH_HOST=
login=neobiker
#-----------------------------------------------
user=neobiker

#$RSYNC_CRYPT -p $provider -s $SSH_HOST -l $login -u $user \

$RSYNC_CRYPT -p $provider -w $WEBDAV -l $login -u $user \
 -r /srv/daten \
 -x Downloads \
    home/neobiker-daten \
    home/neobiker \

EOF

Eine Namenskonvention wie <provider>_<login> bringt etwas Übersicht bei mehreren Providern, Accounts und Benutzern:

$ ls /etc/cryptfs-backup-cloud
t-online_neobiker
t-online_otherUser
1blu_homepage_neobiker
1blu_double_neobiker

Ein Hilfsprogramm liest in Zusammenspiel mit einem Cronjob alle Konfigurationen und startet die Backups nacheinander:

$ cryptfs-backup-cloud [-c] [Konfiguration1] [Konfiguration2] […]

Die Option -c (check) ermittelt per „du -csh“ den belegten Speicherplatz aller konfigurierten Verzeichnisse aus, wobei -x einzelne Verzeichnisse vom Backup ausschliesst. Die Gesamtsumme der fürs Backup definierten Verzeichnisse hilft beim initialen Verteilen der Datenmengen auf die verschiedenen Cloud-Speicher.

$ cryptfs-backup-cloud -c t-online_neobiker
disc usage in configuration t-online_neobiker:
19G     home/neobiker-daten
108K    home/neobiker
19G     insgesamt
    thereof excluded:
8,5G    home/neobiker-daten/Downloads
9,5M    home/neobiker-daten/Documents/Downloads
8,5G    insgesamt

Alle anderen optionalen Parameter werden transparent an das Backup Skript ‚rsync-gocryptfs-cloud‘ durchgereicht.

rsync-gocryptfs-cloud

rsync-gocryptfs-cloud und seine Parameter:

$ rsync-gocryptfs-cloud [-t] [-v] [-d] [-delete] -p <provider> (-w webdav | -s ssh_host | -m mount_point) -l <login> -u <user> [-b <mybackup>] [-x exclude1> [-x exclude2]…] -r <root dir> <dir1> <dir2> <…>

Die Option -t (test) führt einen Testlauf („dry-run“) aus, es werden keine Dateien synchronisiert. Die Option -v (verbose) listet alle von rsync identifizierten Dateien auf, -d (debug) gibt zusätzliche Informationen des Skripts aus, wie z.B. den genauen Aufruf von rsync bzw. find samt den identifizierten Dateien für den anstehenden Backuplauf. Mit -x (exclude) können einzelne Verzeichnisse vom Backup ausgeschlossen werden, -b (backup) bezeichnet das Verzeichnis, in welches die Daten synchronisiert werden, voreingestellt ist „mybackup“. Die Option -m wurde am Schluss hinzugefügt, um das verschlüsselte Backup auch einfach auf einen beliebigen lokalen Mount-Point speichern zu können, z.B. eine externe Festplatte. Ist diese Option definiert, wird kein Remote-Backup gestartet, sondern stattdessen nur ein „lokales“ Backup. So braucht man die normale Remote-Konfiguration nicht anpassen, und kann trotzdem auf einem lokalen Laufwerk das verschlüsselte Backup zusätzlich sichern.

Die Option –delete teilt rsync mit, fehlende (gelöschte) Dateien im Zielsystem auch zu löschen. Sofern ein Zeitstempel des letzten erfolgreichen Backups vorliegt wird kein Fullbackup initiiert. In diesem Fall ermittelt der Befehl find im lokalen Filesystem alle Dateien, welche einen neueren Zeitstempel haben und sendet diese Liste an rsync. Die Option -f (full) initiiert ein Fullbackup trotzdem. Dies stellte sich als sinnvoll heraus, da webdav als Filesystem denkbar schlecht für rsync und dessen Standard Methoden zum Identifizieren von Dateiänderungen geeignet ist. Beim Kopieren von Dateien bleiben Zeitstempel nicht erhalten weshalb die Prüfsumme von Dateien verwendet wird. Die delta-x-fer Option arbeitet bei verschlüsselten Dateien und mit webdav nicht performant. Deshalb bevorzugt das Skript, sofern möglich, die Nutzung von rsync via ssh und verwendet die Option –whole-file. Apropos find im lokalen Filesystem: Hiermit werden natürlich keine Dateien gefunden, welche nachträglich mit einem älterem Zeitstempel in ein Backup-Verzeichnis verschoben wurden (alter Zeitstempel bleibt erhalten). In diesem Fall ist die Option -f für ein Fullbackup einmalig anzuwenden.

Installation

Installation und Beispiele im Detail:

/etc/cryptfs-backup-cloud/*                # individuelle Backup Konfigurationen
/usr/local/sbin/cryptfs-backup-cloud       # Hilfsskript, liest Konfigurationsfiles
/usr/local/sbin/rsync-gocryptfs-cloud      # Backup Skript

Das Passwort zum Ver-/entschlüsseln der Daten liest das Skript standardmäßig aus der Datei /etc/GoCryptFS.PWD. Auf Debian Systemen installiert man gocryptfs am besten aus dem Testing repository, andernfalls ist die Version veraltet. Sshfs benutze ich als Alternative für Cloud-Speicher, welche mir nur ssh aber kein webdav anbieten. Benötigt wird das vom Backup-Skript nicht, sondern nur, wenn ich solchen Cloud-Speicher entschlüsselt wieder einbinden möchte.

$ apt-get install davfs2 gocryptfs rsync sshfs
$ cp cryptfs-backup-cloud rsync-gocryptfs-cloud /usr/local/sbin
$ cd /usr/local/sbin
$ chmod +x cryptfs-backup-cloud rsync-gocryptfs-cloud

Das wars auch schon mit der Installation, jetzt muss das Backup nur noch durch die Backup-Konfigurationsfiles für jeden Benutzer konfiguriert werden.

In den beiden Skripts cryptfs-backup-cloud (Hilfsskript) und rsync-gocryptfs-cloud (Backup Skript) können am Anfang individuelle Konfigurationen angepasst werden. Erwähnenswert ist hier die Variable CHECK_LIMIT. Überschreitet die Anzahl geänderten Dateien seit dem letzten Backuplauf diesen Wert, bricht das Skript mit einer Warnung ab – ein einfaches Mittel z.B. gegen einen Locker-Schädling, damit dieser nicht gleich das Backup mitverschlüsselt. Der einmalige Aufruf mit der Option -f für ein Fullbackup hilft hier, nach einer vorherigen Prüfung (z.B. Optionen -t -v -d) warum das Limit überschritten wurde, das trotzdem alles gesichert wird.

Standardmäßig verwendet das Skript folgende Dateien und Verzeichnisse:

/etc/GoCryptFS.PWD                                  # GoCryptFS Passwort
/etc/cryptfs-backup-cloud/                          # Backup Konfigurationen
/mnt/mybackup-cloud/<provider>/<login>              # assemble backup-dirs
/mnt/mybackup-cloud/gocryptfs/<provider>/<login>    # encrypted dir
/mnt/webdav/<provider>/<login>                      # webdav Cloud-Storage
/mnt/webdav/decrypt/<provider>/<login>              # decrypted <mybackup> dir

Die Konfiguration der Cloudspeicher mit Webdav erfolgt in den beiden Dateien davfs2.conf und secrets im Verzeichnis /etc/davfs2. Der Webdav Cloudspeicher ist in der Datei secrets und /etc/fstab zu konfigurieren:

$ cat /etc/secrets
# T-Online Magentacloud
/mnt/webdav/t-online/neobiker  <Login@t-online.de> "<passwort>"

Zugehöriger /etc/fstab Eintrag zum mounten der Cloud-Speicher:

$ grep davfs /etc/fstab
https://webdav.magentacloud.de/  /mnt/webdav/t-online/neobiker   davfs  rw,noauto,uid=neobiker,gid=User-neobiker,file_mode=777,dir_mode=777 0 0

Damit kann die Konfiguration und der Zugriff auf den Cloudspeicher getestet werden, nachdem noch ein Passwort zur Verschlüsselung definiert wird:

Setze ein Passwort für gocryptfs:

$ echo > /etc/GoCryptFS.PWD „mein GoCryptFS Passwort“
$ chmod 660 /etc/GoCryptFS.PWD 

Anwendungsbeispiele

Die Backup-Konfiguration wurde schon weiter oben definiert. Wieviel Speicherplatz die Konfiguration beinhaltet prüft man mittels:

$ cryptfs-backup-cloud -c t-online_neobiker
disc usage in configuration t-online_neobiker:
19G     home/neobiker-daten
108K    home/neobiker
19G     insgesamt
    thereof excluded:
8,5G    home/neobiker-daten/Downloads
9,5M    home/neobiker-daten/Documents/Downloads
8,5G    insgesamt

Teste das Backup-Skript und den Cloudspeicher Zugriff:

$ cryptfs-backup-cloud -t t-online_neobiker
    bind t-online/jens: home/neobiker-daten
    bind t-online/jens: home/neobiker
2020-05-01 13:01 :  (webdav) start neobiker
    rsync-crypt to t-online: neobiker started full initial sync
/sbin/umount.davfs: warte bis mount.davfs (PID 12852) die Dateien im Cache
gesichert hat .. OK
2020-05-01 13:01: cryptfs-backup-cloud finished

Konfiguration eines Cronjob, der täglich um 01:31 Uhr das Backup startet:

$ crontab -e
### Cloud-Server Remote Backup
31 01 * * * /usr/local/sbin/cryptfs-backup-cloud

Nützliche Aliase für die Standardkonfiguration des Skriptes in ~/.bash_aliases:

alias mount_t-online_neobiker='mount /mnt/webdav/t-online/neobiker'
alias mountCFS_t-online_neobiker_CFS='gocryptfs -passfile /etc/GoCryptFS.PWD -config /mnt/mybackup-cloud/gocryptfs/.config/t-online_neobiker.reverse.conf /mnt/webdav/t-online/neobiker/mybackup /mnt/webdav/decrypt/t-online/neobiker'

$ webdav_t-online_neobiker       # mountet den MagentaCloud Speicher nach /mnt/webdav/t-online_neobiker
$ webdav_t-online_neobiker_CFS   # entschlüsselt das Crypted-Backup unter /mnt/webdav/decrypt/t-online_neobiker

Anwendungsfall 1: Homeverzeichnisse per WebDav in MagentaCloud von T-Online sichern, wurde im Artikel ausgeführt Verzeichnis von T-Online mounten (/etc/fstab Eintrag ist vorhanden, oder alias verwenden):

$ mount /mnt/webdav/t-online/neobiker/

Backup Verzeichnis mounten und Datei wiederherstellen (verwendet obigen alias):

$ mountCFS_tonline_neobiker
$ cp /mnt/webdav/decrypt/t-online/neobiker/home/neobiker-daten/Documents/Cryptfs_Artikel.docx .

Anwendungsfall 2: Es wird rsync direkt mittels SSH zur Synchronisation der Dateien benutzt. SSHFS wird als Alternative zu webdav verwendet, um den Cloud-Speicher zu mounten:

alias sshfs_1blu='sshfs <login>@<webhosting_host>.1blu.de: /mnt/webdav/1blu/<login>/'

Konfiguration eines SSH Cloud-Speicher bei 1Blu:

$ cat /etc/cryptfs-backup-cloud/1blu_homepage_neobiker
#!/bin/sh
# my cryptfs-backup-cloud script
# rsync an encrypted filesystem to cloud storage
[ -z "$RSYNC_CRYPT" ] && RSYNC_CRYPT=/usr/local/sbin/rsync-gocryptfs-cloud
#-----------------------------------------------
provider=1blu                                  # provider name
WEBDAV=                                        # URL of provider cloud storage
SSH_HOST=<webhosting_host>.1blu.de
login=<1blu login>
#-----------------------------------------------
user=neobiker

#$RSYNC_CRYPT -p $provider -w $WEBDAV -l $login -u $user \

$RSYNC_CRYPT -p $provider -s $SSH_HOST -l $login -u $user \
 -r /srv/daten \
    data/homepage \

Beispiel des Speicherns dieses Artikels mit den Optionen -v(erbose) und -d(ebug): Man sieht die Aufrufparameter von mount, find und rsync und den letztlichen Aufruf mit allen Parametern:

$ cryptfs-backup-cloud -d -v t-online_neobiker
2020-05-22 17:10: rsync-gocryptfs-cloud assemble for t-online: neobiker
    bind t-online/neobiker: home/neobiker-daten
    bind t-online/neobiker: home/neobiker
2020-05-22 17:10: mount -t davfs -o uid=neobiker,gid=User-neobiker,file_mode=770,dir_mode=770 https://webdav.magentacloud.de/ /mnt/webdav/t-online/neobiker
2020-05-22 17:10 :  (webdav) start neobiker
2020-05-22 17:10: find /mnt/mybackup-cloud/t-online/neobiker/home/ -path */temp -prune -o -path */Temp -prune -o -path */Downloads -prune -o -path */Downloads -prune -o -newer /mnt/mybackup-cloud/t-online/neobiker/.backup -type f -print
Files to sync: 1   (rm /mnt/mybackup-cloud/t-online/neobiker/.backup for full backup)
find -newer:
home/neobiker-daten/Documents/Cryptfs_Artikel.docx
    rsync to t-online: neobiker started
2020-05-22 17:10: nice rsync --files-from=- --whole-file --bwlimit 1.5m --ignore-errors --exclude-from /var/run/rsync_exclude_6764 --exclude temp --exclude Temp --exclude Downloads --exclude Downloads --verbose --stats --checksum /mnt/mybackup-cloud/gocryptfs/t-online/neobiker/ /mnt/webdav/t-online/neobiker/mybackup/
find -newer:
XdLfx5-75ieq8bMIYGeP7Q==/-eFqsSvk2rnYpMpT8PCxvA==/ZrfIzMtF9hLwBx7WozrLDg==/1UsMcd37sCt4lHaTK2Nw_G1Ei7fo5mRjfi00xJ2GbQc=
XdLfx5-75ieq8bMIYGeP7Q==/-eFqsSvk2rnYpMpT8PCxvA==/ZrfIzMtF9hLwBx7WozrLDg==/gocryptfs.diriv
building file list ... done
XdLfx5-75ieq8bMIYGeP7Q==/-eFqsSvk2rnYpMpT8PCxvA==/ZrfIzMtF9hLwBx7WozrLDg==/1UsMcd37sCt4lHaTK2Nw_G1Ei7fo5mRjfi00xJ2GbQc=

Number of files: 5 (reg: 2, dir: 3)
Number of created files: 0
Number of deleted files: 0
Number of regular files transferred: 1
Total file size: 82,656 bytes
Total transferred file size: 82,640 bytes
Literal data: 82,640 bytes
Matched data: 0 bytes
File list size: 0
File list generation time: 0.592 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 82,976
Total bytes received: 31

sent 82,976 bytes  received 31 bytes  33,202.80 bytes/sec
total size is 82,656  speedup is 1.00
2020-05-22 17:10: rsync to t-online: jens (ok)
/sbin/umount.davfs: warte bis mount.davfs (PID 7018) die Dateien im Cache
gesichert hat .. OK
2020-05-22 17:10: cryptfs-backup-cloud finished

Skripts

cryptfs-backup-cloud

#!/bin/sh
# read configuration files from a config dir
# rsync my directories encrypted to cloud storage
# neobiker (2020)

# --- individual configuration ---

CONF_DIR=/etc/cryptfs-backup-cloud                 # read and execute all scripts

RSYNC_CRYPT=/usr/local/sbin/rsync-gocryptfs-cloud  # my rsync-gocryptfs-cloud script

CHECK_MOUNTS=/srv                                  # if set, exit script if it is not a mounted filesyst

# --- end of individual configuration ---

# don't start when another instance is (still?) running

prg=`basename $0`
run=$( ps ax|awk '{print $5}'|grep -c $0 )
pid_file=/run/${prg}.pid
if [ "0$run" -gt 1 ]; then
    if [ -e $pid_file -a $( cat $pid_file ) != $$ ]; then
        echo "Warning: $prg already running ($run times). Exiting"
        exit 1
    fi
fi
echo $$ > $pid_file

# only option -c is relevant for myself
# all other options are just forwarded to $RSYNC_CRYPTFS
# otherwise i will execute the configuration scripts

while [ "$#" -gt "0" ]; do
    case "$1" in
        -c)
            check_config=true
            ;;

        # read additional params ... just forward most of them
        -t|-d|-v|-f|--delete)
            RSYNC_CRYPT="$RSYNC_CRYPT $1"
            ;;
        -m) shift
            RSYNC_CRYPT="$RSYNC_CRYPT -m $1"
            ;;
        -x) shift
            RSYNC_CRYPT="$RSYNC_CRYPT -x $1"
            skipped_data="$skipped_data $1"
            ;;
        *)
           break
           ;;
    esac
    shift
done

# process all dirs in $CONF_DIR, or
dirs='*'

# only specified dirs
[ -n "$*" ] && dirs=$*

# if defined, check my SOURCE filesystems
# skip if i'm not a fileserver

[ -n "$MOUNT" ] && for mnt in $MOUNT; do
  if ! mount | grep -q $mnt; then
    if ! mount $mnt; then
        echo "Error: mount $mnt failed."
        exit 1
    fi
  fi
done

#
# i just check the configuration file
# using du -s for all dirs
#
check_backup_config ()
{
  data_skipped=""

  # read configuration -r <root_dir> -x <exclude dir> ... <src1> ...
  while [ "$#" -gt "0" ]; do
    case "$1" in
        -h|-d|-t|-f|-v)           # skip options -t -f -v -d -h
            ;;
        -p|-w|-s|-l|-b|-u) shift  # skip parameter -p <provider> -w <webdav> -l <login> -u <uid>
            ;;
        -x) shift
            data_skipped="$data_skip -name $1"
            ;;
        -r) shift
            data_root=$1
            ;;
        *)
           break
           ;;
    esac
    shift
  done

  echo disc usage in configuration $( basename $backup_script ):
  (cd $data_root; du -c -s -h $*)
  [ -n "$data_skipped" ]&& echo "    thereof excluded:"
  [ -n "$data_skipped" ]&& (cd $data_root; find $* $data_skipped | xargs du -csh)
  echo
}

# ---------------------------------------------------------
# run backup scripts, or check disk usage in configurations
# ---------------------------------------------------------
for backup_script in $CONF_DIR/$dirs; do

    if [ "$check_config" = "true" ]; then
        RSYNC_CRYPT=echo
        check_backup_config $( . $backup_script )

    else
        # run the backup script
        . $backup_script
    fi
done

[ -e /run/${prg}.pid ]&& rm /run/${prg}.pid
echo `date +"%F %R"`: $prg finished

rsync-gocryptfs-cloud

#!/bin/bash
# rsync files encrypted by gocryptfs
# via davfs2 or rsync-ssh
#
# Description:
# backup encrypted (gocryptfs) data to
# webdav mount-point of provider cloud storage
# or by rsync via ssh
#
# data directories will be assembled (--bind) to a temporary
# rsync directory, which will be virtually encrypted by gocryptfs
# and synced via rsync to backup directory
#
# $data_dir (src) -> $rsync_dir (bind) -> $crypt_dir (crypted) -> $backup_dir (e.g. cloud)
#
# Author: neobiker (2020)

# --- individual configuration ---

BACKUP=mybackup                     # remote backup directory on cloud storage
CHANGE_LIMIT=300                    # don't sync if more than X files changed

                                    # list directories to skip during in backup
                                    # think about, can be set by -x <dir> also
RSYNC_EXCLUDE="$RSYNC_EXCLUDE --exclude temp"
RSYNC_EXCLUDE="$RSYNC_EXCLUDE --exclude Temp"
RSYNC_EXCLUDE="$RSYNC_EXCLUDE --exclude Downloads"

WEBDAV_MNT=/mnt/webdav              # webdav mount point for provider cloud storage
BACKUP_SRC=/mnt/mybackup-cloud      # assemble the backup dirs by --bind mounts here
CRYPTFS_MNT=$BACKUP_SRC/gocryptfs   # create encrypted filesystem
DECRYPTED=$WEBDAV_MNT/decrypt       # mount decrypted webdav filesystem here (not used in this script)

# rsync options
RSYNC="nice rsync"
#OPT_RSYNC="$OPT_RSYNC --no-whole-file" # makes no sense whith encryption
OPT_RSYNC="$OPT_RSYNC --whole-file"     # makes sense whith encryption
OPT_RSYNC="$OPT_RSYNC --bwlimit 1.5m"   # works not with davfs mount :-(
#OPT_RSYNC="$OPT_RSYNC --safe-links"

# GoCryptFS is used for encryption
CRYPTFS=gocryptfs
OPT_CFS="-reverse"                  # don't change reverse mode
OPT_CFS="$OPT_CFS -passfile /etc/GoCryptFS.PWD" # eg. link to /run/YourPassWord read from encrypted device on boot ;-)
OPT_CFS="$OPT_CFS -quiet"           # your choice

# --- end of individual configuration ---

cat > /var/run/rsync_exclude_$$ <<-EOF
        lost+found
        System Volume Information
        \$RECYCLE.BIN
        gocryptfs.conf
EOF
OPT_RSYNC="$OPT_RSYNC --ignore-errors --exclude-from /var/run/rsync_exclude_$$"
OPT_RSYNC="$OPT_RSYNC $RSYNC_EXCLUDE"

for exclude_dir in $(echo "$RSYNC_EXCLUDE" | tr = \  ); do
    [ $exclude_dir != "--exclude" ] && OPT_FIND="$OPT_FIND -path */$exclude_dir -prune -o"
done

print_usage ()
{
        echo "Usage: `basename $0` -p <provider> (-w <webdav> | -s <ssh_host> | -m <mount_point>) -l <login> -u <uid>"
        echo "       [-b <remote backup_dir (mybackup)>] [-f(ull)] [-v(erbose)] [-t(est)] [-d(ebug)] [--delete]"
        echo "       [[-x <exclude dir1>] [-x <exclude dir2>] ...]"
        echo "       -r <data_root> <src1 relative to data_root> [<src2 relative to data_root> ...]"
}

myname=$(basename $0)
delete=false                        # use --delete option
verbose=false                       # use -v option
test_run=false                      # use -t option
full_sync=false                     # use -f option
DEBUG=false                         # use -d option

if [ "$#" -le 10 ]; then
    print_usage
    exit 1
fi

# read params <provider> <webdav> <login> <uid> <src1> ...
while [ "$#" -gt "0" ]; do
    case "$1" in
        -h)
            help=true
            ;;
        -p) shift
            provider=$1
            ;;
        -w) shift
            WEBDAV=$1
            ;;
        -s) shift
            SSH_HOST=$1
            ;;
        -b) shift
            BACKUP=$1
            ;;
        -l) shift
            login=$1
            ;;
        -m) shift
            mount_point=$1
            ;;
        -u) shift
            user_id=$1
            ;;
        -r) shift
            data_root=$1
            ;;
        -x) shift
            OPT_RSYNC="$OPT_RSYNC --exclude $1"
            OPT_FIND="$OPT_FIND -path */$1 -prune -o"
            ;;
        -f)
            full_sync=true
            ;;
        --delete)
            delete=true
            ;;
        -d)
            DEBUG=true
            ;;
        -v)
            verbose=true
            ;;
        -t)
            test_run=true
            ;;
        *)
           break
           ;;
    esac
    shift
done

if [ -n "$help" ]; then
    print_usage
    exit 0
fi

if [ -z "$user_id" -o -z "$login" -o -z "$provider" -o -z "$SSH_HOST$WEBDAV" ]; then
    if [ -z "$mount_point" ]; then
        echo "Error: missing arguments for backup directory"
        echo "Error: either use -m <mount_point> or -s <SSH_HOST> or -w <WEBDAV>"
        print_usage
        exit 1
    fi
fi

if [ -z "$data_root" -o ! -e "$data_root" ]; then
    echo "Error: missing or wrong -r <data_root>"
    print_usage
    exit 1
fi

# skip, if no <src> ... dirs defined
if [ -z "$*" ]; then
  echo "Error: missing <source dirs>"
  print_usage
  exit 1
fi

# simple debug
debug_echo ()
{
        $DEBUG && echo `date +"%F %R"`: $*
}

$test_run && OPT_RSYNC="$OPT_RSYNC --dry-run"
$verbose && OPT_RSYNC="$OPT_RSYNC --verbose"
$delete && OPT_RSYNC="$OPT_RSYNC --delete"
$DEBUG && OPT_RSYNC="$OPT_RSYNC --stats"

# ----------------------------------------------------------
# rsync-cryptfs:  <$src>  ->  $webdav_dir/$BACKUP
# ----------------------------------------------------------
# assemble $data_dir  -> $rsync_dir    (bind -ro src1 ...)
# crypt    $rsync_dir -> $crypt_dir    (cryptfs -ro)
# rsync    $crypt_dir -> $backup_dir   (webdav or rsync ssh)
# ----------------------------------------------------------
rsync_dir=$BACKUP_SRC/$provider/$login
crypt_dir=$CRYPTFS_MNT/$provider/$login
webdav_dir=$WEBDAV_MNT/$provider/$login
backup_dir=$webdav_dir/$BACKUP

[ -e $rsync_dir  ] || mkdir -p $rsync_dir
[ -e $crypt_dir  ] || mkdir -p $crypt_dir
[ -e $webdav_dir ] || mkdir -p $webdav_dir

# this would de-/encrypt the file-/dirnames, but it doesn't work in my host :-(
# OPT_CFS="$OPT_CFS -ctlsock $rsync_dir/.ctlsock"

# --------------------------------
# we use rsync via ssh if possible
# --------------------------------
if [ -n "$SSH_HOST" ]; then
    method=ssh
    backup_dir=$SSH_HOST:$BACKUP
    export RSYNC_RSH="ssh -l $login"
    OPT_RSYNC="$OPT_RSYNC --times"    # rsync-ssh preserves times
else
    method=webdav
    OPT_RSYNC="$OPT_RSYNC --checksum" # webdav doesn't preserve time
fi

# a local mount can always be used instead of the remote backup
if [ -n "$mount_point" ]; then
    method=mount
    backup_dir=$mount_point/$BACKUP
    debug_echo Info: backup_dir=$mount_point/$BACKUP
fi

# -----------------------------------------------
# webdav parameters: mount with defined $uid $gid
# -----------------------------------------------
uid=$(id -un $user_id)
gid=$(id -gn $uid)
OPT_DAV="-o uid=$uid,gid=$gid,file_mode=770,dir_mode=770"

# -------------------------------------------
# assemble all source dirs:
#     mount --bind $<src1> $rsync_dir/$<src1>
#     mount --bind $<src2> $rsync_dir/$<src2>
#       ...
# -------------------------------------------
assemble_src ()
{
    debug_echo "    $myname assemble for $provider: $login"
    logger -t $myname "assemble-source-dirs for $provider: $login"

    # clear assemble area at start ($rsync_dir)
    for m in $( mount|grep $rsync_dir|cut -d\  -f3 ); do
        debug_echo "    Info: umount $m"
        umount $m
    done

    # assemble all src dir into $rsync_dir
    ret=1
    for src in $*; do

        # -------------------------------
        # mount (--bind) $src  $rsync_dir
        # -------------------------------
        if [ -d $data_root/$src ]; then
            # check if it is already mounted (double listed?)
            mount | cut -d\  -f3 | grep -q $rsync_dir/$src && continue

            # we need a dir to mount
            [ -d $rsync_dir/$src ] || mkdir -p $rsync_dir/$src
            if mount --bind -o ro $data_root/$src $rsync_dir/$src; then
                ret=0
                echo "    bind $provider/$login: $src"
                logger -t $myname "bind $provider/$login: $src"
            else
                logger -t $myname "Error: mount --bind $src failed"
            fi

        else
            echo "Warning: $data_root/$src not found, skipped"
        fi
    done
    return $ret
}

# ---------------------------------------------------
# gocryptfs --reverse  $rsync_dir  ->  $crypt_dir
# ---------------------------------------------------
mount_cryptfs ()
{
    # cryptfs config file should never be synced to cloud!
    cfs_config=$CRYPTFS_MNT/.config/${provider}_${login}.reverse.conf

    # don't mount me twice
    if ! mount | grep gocryptfs-reverse | cut -d\  -f3 | grep -q "$crypt_dir "; then

        # check if cryptfs is already initialized
        ret=1
        if [ ! -e $cfs_config ]; then
            # init cryptfs reverse view
            logger -t $myname "$CRYPTFS -init -reverse $rsync_dir"
            $CRYPTFS -init $OPT_CFS -config $cfs_config $rsync_dir 2>/dev/null
        fi

        # mount cryptfs view
        logger -t $myname "$CRYPTFS -reverse $rsync_dir $crypt_dir"
        $CRYPTFS $OPT_CFS -config $cfs_config $rsync_dir $crypt_dir
        ret=$?
    else
        echo "Warning: gocryptfs already mounted $crypt_dir"
        ret=0
    fi
    return $ret
}

# ---------------------------------------------------
# webdav mount only if 'rsync -e ssh' isn't available
# ---------------------------------------------------
mount_backup_dir ()
{
    # ----------------------------
    # local mountpoint configured?
    # ----------------------------
    if [ $method = "mount" ]; then

        # avoid wrong (former) mounts
        if mount | cut -d\  -f3 | grep -q "$mount_point "; then
            debug_echo "    Info: umount $mount_point"
            umount "$mount_point"
        fi

        # ----------------------
        # mount local mountpoint
        # ----------------------
        if ! mount | cut -d\  -f3 | grep -q "$mount_point "; then
            debug_echo "    mount $mount_point"
            if ! mount $mount_point; then
                ret=$?
                echo "Error: mount $mount_point failed (ret=$ret)."
                return $ret
            else
                [ -e $backup_dir ] || mkdir -p $backup_dir
            fi
        else
            echo "Warning: $mount_point was already mounted, skipped."
        fi

    elif [ $method = "webdav" ]; then

        # avoid wrong (former) webdav mounts (e.g. wrong uid gid)
        if mount | cut -d\  -f3 | grep -q "$webdav_dir "; then
            debug_echo "    Info: umount $webdav_dir"
            umount "$webdav_dir"
        fi

        # ----------------------------
        # mount $WEBDAV to $webdav_dir
        # ----------------------------
        DAV_PID=$(echo $webdav_dir | cut -d/ -f2- | sed -e 's#/#-#g').pid
        if ! mount | cut -d\  -f3 | grep -q "$webdav_dir "; then
            [ -f "/var/run/mount.davfs/$DAV_PID" ] && rm /var/run/mount.davfs/$DAV_PID
            debug_echo "    mount -t davfs $OPT_DAV $WEBDAV $webdav_dir"

            if ! mount -t davfs $OPT_DAV $WEBDAV $webdav_dir; then
                ret=$?
                echo "Error: mount $WEBDAV $webdav_dir failed (ret=$ret)."
                return $ret
            fi
        else
            echo "Warning: $webdav_dir was already mounted, skipped."
        fi
    fi
}

# ----------------------------------------
# my backup rsync function for webdav dirs
# ----------------------------------------
# use 'find -newer' in order to create the list of files
# which changed since last successful backup

# --------------------------------------
# rsync $crypt_dir/$src $backup_dir/$src
# --------------------------------------
backup_encrypted_data ()
{
    echo `date +"%F %R"` ": $maname ($method) start $provider_$login"

    # some stat markers
    backup_start=.backup_start
    backup_last=.backup

    if [ ! -d $crypt_dir ]; then
        echo "Error: missing <crypt_dir> for backup_encrypted_data()"
        return
    fi
    if [ -z "$SSH_HOST" -a ! -d $backup_dir ]; then
        echo "Error: missing <backup_dir> for backup_encrypted_data()"
        return
    fi

    # initial full backup ?
    # otherwise, only "newer" files will be synced (to reduce remote rsync file-checks)
    if [ "$full_sync" != "true" -a -e $rsync_dir/$backup_last ]; then

        # check how many files changed since last backup
        debug_echo find $rsync_dir/*/ $OPT_FIND -newer $rsync_dir/$backup_last -type f -print
        file_nr=$( find $rsync_dir/*/ $OPT_FIND -newer $rsync_dir/$backup_last -type f -print | wc -l )
        echo "Files to sync: $file_nr   (rm $rsync_dir/$backup_last for full backup)"
        $DEBUG && ( echo "find -newer: "; cd $rsync_dir; find */ $OPT_FIND -newer $rsync_dir/$backup_last -type f -print )

        # skip backup if $CHANGE_LIMIT is exceeded
        if [ $CHANGE_LIMIT -ne 0 -a $file_nr -gt $CHANGE_LIMIT ]; then
            echo "Warning: MANY Files changed."
            echo "Info   : Check if 'full sync' is needed (rm $rsync_dir/$backup_last to trigger full sync)"
            echo "Error  : Skipping Sync (to prevent Crypto-Locker Virus)"
            ret=1000

        # ------------------------------------------------------------
        # backup only "newer" files since last backup -> partial rsync
        # ------------------------------------------------------------
        else
            if [ $file_nr -ne 0 ] ; then

                echo "    rsync to $provider: $login started"
                logger -t $myname "rsync to $provider: $login started "
                debug_echo $RSYNC --files-from=- $OPT_RSYNC $crypt_dir/ $backup_dir/
                $DEBUG && ( echo "find -newer: "; cd $crypt_dir; find */ $OPT_FIND -newer $rsync_dir/$backup_last -type f -print )

                $test_run || touch $rsync_dir/$backup_start

                $RSYNC $crypt_dir/gocryptfs.diriv $backup_dir/
                ( cd $crypt_dir; find */ $OPT_FIND -newer $rsync_dir/$backup_last -type f -print ) | \
                $RSYNC $OPT_RSYNC --files-from=- $crypt_dir/ $backup_dir/
                ret=$?

                [ $ret -ne 0 ] && logger -t $myname "rsync to $provider: $login (RET = $ret)"

            else
                ret=0
            fi
        fi

    else
        # --------------------------------------------
        # no backup_last timestamp found -> full rsync
        # --------------------------------------------
        echo "    rsync-crypt to $provider: $login started full initial sync"
        logger -t $myname "rsync-crypt to $provider: $login started full initial sync"

        $test_run || touch $rsync_dir/$backup_start
        crypted_dirs=$( cd $crypt_dir; find * -maxdepth 0 -type d -printf '%f ' )
        debug_echo "$RSYNC $OPT_RSYNC gocryptfs.diriv $crypted_dirs $backup_dir/"

        ( cd $crypt_dir; $RSYNC $OPT_RSYNC -r gocryptfs.diriv $crypted_dirs $backup_dir/ )
        ret=$?

        [ $ret -ne 0 ] && logger -t $myname "rsync to $provider: $login (RET = $ret)"
    fi

    if [ $ret -eq 0 ]; then
        [ -e $rsync_dir/$backup_start -a $test_run = "false" ] && mv $rsync_dir/$backup_start $rsync_dir/$backup_last
        logger -t $myname "rsync to $provider: $login (ok)"
        debug_echo "    rsync to $provider: $login (ok)"
    else
        logger -t $myname "rsync to $provider: $login (RET = $ret)"
    fi
    [ -e $rsync_dir/$backup_start ] && rm $rsync_dir/$backup_start
    return $ret
}

# ----------------------------------------------------
# assemble directories to be backed up into $rsync_dir
# ----------------------------------------------------
if assemble_src $*; then

    # ---------------------------------------
    # CRYPTFS  $rsync_dir <-> $crypt_dir
    # ---------------------------------------
    if mount_cryptfs; then

        # ----------------------------------------------
        # mount backup directory (webdav or local mount)
        # ----------------------------------------------
        if mount_backup_dir; then

            # ------------------------------
            # backup encrypted directory
            # ------------------------------
            backup_encrypted_data

        fi
    fi
fi
rm /var/run/rsync_exclude_$$

# ---------------------------------------------
# just to be sure to umount all dirs at the end
# ---------------------------------------------
for m in $(mount|grep $rsync_dir|cut -d\  -f3); do
    logger -t $myname "umount: $m"
    umount $m
done
for m in $(mount|grep $crypt_dir|cut -d\  -f3); do
    logger -t $myname "umount: $m"
    umount $m
done

# --------------------------------
# umount $webdav_dir, work is done
# --------------------------------
if mount | cut -d\  -f3 | grep -q $webdav_dir; then
    umount $webdav_dir
    logger -t $myname "umount: $webdav_dir"
fi