Kapitel 10. Datenmanagement

# Kapitel 10. Datenmanagement

Hier werden Werkzeuge und Tipps zur Verwaltung von Binär- und Textdateien auf einem Debian-System beschrieben.

## 10.1. Austauschen, kopieren und archivieren von Dateien

| Warnung
Nicht-koordinierte zeitgleiche Schreibzugriffe auf Geräte und Dateien durch mehrere Prozesse sind nicht erlaubt, da dadurch eine Race Condition (Wettlaufsituation um konkurrierende Zugriffe auf die Ressource) entstehen könnte. Dies kann über einen File locking-Mechanismus mittels flock(1) umgangen werden.

Die Sicherheit der Daten und deren kontrolliertes Austauschen mit anderen hat verschiedene Aspekte:

- Erzeugung von Datenarchiven;

- Fern-Speicherzugriff;

- Vervielfältigung;

- Nachverfolgung der Änderungshistorie;

- Erleichterung des Tauschens von Daten;

- Verhinderung von unerlaubten Dateizugriffen;

- Erkennung von unerlaubten Dateiveränderungen.

Diese können über die Verwendung einer Kombination von Werkzeugen realisiert werden:

- Archivierungs- und Kompressionswerkzeuge

- Kopier- und Synchronisationswerkzeuge

- Netzwerk-Dateisysteme;

- Wechseldatenträger;

- Secure Shell;

- Authentifizierungssysteme;

- Versionskontrollsysteme;

- Hash- und kryptographische Verschlüsselungswerkzeuge.

### 10.1.1. Archivierungs- und Kompressionswerkzeuge

Hier eine Zusammenfassung von Archivierungs- und Kompressionswerkzeugen im Debian-System:

Tabelle 10.1. Liste von Archivierungs- und Kompressionswerkzeugen

Paket | Popcon | Größe | Erweiterung | Befehl | Erläuterung
--- | --- | --- | --- | --- | ---
`tar` | V:906, I:1000 | 3101 | `.tar` | tar(1) | Standard-Archivierungs-Programm (De-Facto-Standard)
`cpio` | V:354, I:999 | 1201 | `.cpio` | cpio(1) | Unix-Archivier-Programm im System-V-Stil, zu verwenden mit find(1)
`binutils` | V:190, I:637 | 1119 | `.ar` | ar(1) | Archivier-Programm zur Erstellung von statischen Bibliotheken
`fastjar` | V:0.9, I:9.8 | 182 | `.jar` | fastjar(1) | Archivier-Programm für Java (zip-artig)
`pax` | V:5.4, I:9.5 | 167 | `.pax` | pax(1) | neues POSIX-Archivier-Programm, Kompromiss zwischen `tar` und `cpio`
`gzip` | V:902, I:1000 | 256 | `.gz` | gzip(1), zcat(1), … | GNU LZ77-Kompressionswerkzeug (De-Facto-Standard)
`bzip2` | V:159, I:972 | 113 | `.bz2` | bzip2(1), bzcat(1), … | Burrows-Wheeler Block-Sorting Kompressions-Werkzeug mit höherem Kompressionsverhältnis als gzip(1) (langsamer als `gzip` mit ähnlicher Syntax)
`lzma` | V:1, I:10 | 349 | `.lzma` | lzma(1) | LZMA-Kompressionswerkzeug mit höherem Kompressionsverhältnis als gzip(1) (überholt)
`xz-utils` | V:309, I:981 | 1520 | `.xz` | xz(1), xzdec(1), … | XZ-Kompressionswerkzeug mit höherem Kompressionsverhältnis als bzip2(1) (langsamer als `gzip`, aber schneller als `bzip2`; ersetzt das LZMA-Kompressionswerkzeug)
`zstd` | V:319, I:814 | 2308 | `.zstd` | zstd(1), zstdcat(1), … | Zstandard: schnelles verlustfreies Kompressionswerkzeug
`p7zip` | V:5, I:184 | 8 | `.7z` | 7zr(1), p7zip(1) | 7-Zip-Dateiarchivier-Programm mit hohem Kompressionsverhältnis (LZMA-Kompression)
`p7zip-full` | V:15, I:210 | 12 | `.7z` | 7z(1), 7za(1) | 7-Zip-Dateiarchivier-Programm mit hohem Kompressionsverhältnis (LZMA- und andere Kompressionsalgorithmen)
`lzop` | V:12, I:132 | 164 | `.lzo` | lzop(1) | LZO-Kompressionswerkzeug mit höherer Kompressions- und Dekompressionsgeschwindigkeit als gzip(1) (niedrigeres Kompressionsverhältnis als `gzip` mit ähnlicher Syntax)
`zip` | V:48, I:360 | 635 | `.zip` | zip(1) | InfoZIP: DOS-Archivierungs- und Kompressionswerkzeug
`unzip` | V:109, I:747 | 399 | `.zip` | unzip(1) | InfoZIP: DOS-Dearchivierungs- und Dekompressionswerkzeug

| Warnung
Setzen Sie nicht die "`$TAPE`"-Variable, außer Sie sind sich über die Folgen im klaren. Sie verändern dadurch das Verhalten von tar(1).

- Ein gezipptes tar(1)-Archiv verwendet die Dateierweiterung "`.tgz`" oder "`.tar.gz`".

- Ein xz-komprimiertes tar(1)-Archiv verwendet die Dateierweiterung "`.txz`" oder "`.tar.xz`".

- Die Popularität der Kompressionsmethoden in FOSS-Programmen wie tar(1) hat sich mit der Zeit wie folgt verschoben: `gzip` → `bzip2` → `xz`.

- cp(1), scp(1) und tar(1) könnten Einschränkungen bei speziellen Dateien haben. cpio(1) ist dabei erheblich vielseitiger.

- cpio(1) wurde entwickelt, um zusammen mit find(1) und anderen Befehlen verwendet zu werden und ist geeignet, Backup-Skripte zu erstellen, da der Teil des Skriptes zur Dateiauswahl eigenständig getestet werden kann.

- Die interne Struktur von Libreoffice-Dateien entspricht der von "`.jar`"-Dateien, die auch mit `unzip` geöffnet werden können.

- Das de-facto plattform-übergreifende Archivwerkzeug ist `zip`. Benutzen Sie es in der Art "`zip -rX`", um maximal mögliche Kompatibilität zu erreichen. Verwenden Sie auch die Option "`-s`", wenn die maximale Dateigröße bei Ihnen relevant ist.

### 10.1.2. Kopier- und Synchronisationswerkzeuge

Hier eine Zusammenfassung von einfachen Kopier- und Backup-Werkzeugen im Debian-System:

Tabelle 10.2. Liste von Kopier- und Synchronisationswerkzeugen

Paket | Popcon | Größe | Werkzeug | Funktion
--- | --- | --- | --- | ---
`coreutils` | V:910, I:1000 | 17994 | GNU cp | Dateien und Verzeichnisse lokal kopieren (verwenden Sie "`-a`" für rekursive Operationen)
`openssh-client` | V:657, I:996 | 3521 | scp | Dateien und Verzeichnisse von fern kopieren (Client, verwenden Sie "`-r`" für rekursive Operationen)
`openssh-server` | V:772, I:820 | 3594 | sshd | Dateien und Verzeichnisse von fern kopieren (ferner Server)
`rsync` | V:196, I:542 | 835 |  | 1-Weg-Synchronisation und -Backup von fern
`unison` | V:2, I:11 | 14 |  | 2-Wege-Synchronisation und -Backup von fern

Das Kopieren von Dateien mit rsync(8) bietet mehr Funktionalitäten als mit anderen Werkzeugen:

- Delta-Transfer-Algorithmus, der nur die Unterschiede zwischen Quelle und Ziel überträgt;

- schneller Prüf-Algorithmus, der (standardmäßig) nach Dateien sucht, die sich in Größe oder Änderungs-Zeitstempel verändert haben;

- die Optionen "`--exclude`" und "`--exclude-from`", vergleichbar mit denen von tar(1);

- die Syntax des Schrägstrichs hinter dem Quellverzeichnis, die verhindert, dass eine zusätzliche Verzeichnisebene auf dem Zielort erstellt wird.

| Tipp
Versionskontrollsysteme (VCS) wie die in Tabelle 10.14, „Liste anderer Versionskontrollsystem-Werkzeuge“ können ebenfalls als Mehrwege-Kopier- und Synchronisationswerkzeuge dienen.

### 10.1.3. Aufrufe für Archivierungsoperationen

Hier finden Sie mehrere Wege, um den kompletten Inhalt des Verzeichnisses "`./source`" mit verschiedenen Werkzeugen zu archivieren oder dearchivieren.

GNU tar(1):

    $ tar -cvJf archive.tar.xz ./source
    $ tar -xvJf archive.tar.xz

Alternativ auch:

    $ find ./source -xdev -print0 | tar -cvJf archive.tar.xz --null -T -

cpio(1):

    $ find ./source -xdev -print0 | cpio -ov --null > archive.cpio; xz archive.cpio
    $ zcat archive.cpio.xz | cpio -i

### 10.1.4. Aufrufe für Kopieroperationen

Hier finden Sie mehrere Wege, um den kompletten Inhalt des Verzeichnisses "`./source`" mit verschiedenen Werkzeugen zu kopieren.

- Lokale Kopie: "`./source`"-Verzeichnis → "`/dest`"-Verzeichnis

- Kopie auf einen fernen Rechner: "`./source`"-Verzeichnis auf dem lokalen Rechner → "`/dest`"-Verzeichnis auf dem Rechner "`user@host.dom`"

rsync(8):

    # cd ./source; rsync -aHAXSv . /dest
    # cd ./source; rsync -aHAXSv . user@host.dom:/dest

Sie können auch die Syntax mit Schrägstrich am Ende des Zielverzeichnisses nutzen:

    # rsync -aHAXSv ./source/ /dest
    # rsync -aHAXSv ./source/ user@host.dom:/dest

Alternativ auch:

    # cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . /dest
    # cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . user@host.dom:/dest

GNU cp(1) und openSSH scp(1):

    # cd ./source; cp -a . /dest
    # cd ./source; scp -pr . user@host.dom:/dest

GNU tar(1):

    # (cd ./source && tar cf - . ) | (cd /dest && tar xvfp - )
    # (cd ./source && tar cf - . ) | ssh user@host.dom '(cd /dest && tar xvfp - )'

cpio(1):

    # cd ./source; find . -print0 | cpio -pvdm --null --sparse /dest

Sie können in allen Beispielen, die einen "`.`" enthalten, diesen "`.`" durch "`foo`" ersetzen, um Dateien aus dem Verzeichnis "`./source/foo`" in das Verzeichnis "`/dest/foo`" zu kopieren.

Auch kann in allen Beispielen, die einen "`.`" enthalten, dieser "`.`" durch einen absoluten Pfad wie "`/pfad/zu/source/foo`" ersetzt werden, damit kann dann auf "`cd ./source;`" verzichtet werden. Dadurch werden, abhängig von den verwendeten Werkzeugen, die Dateien an unterschiedliche Orte kopiert:

- bei rsync(8), GNU cp(1) und scp(1): nach "`/dest/foo`";

- bei GNU tar(1) und cpio(1): nach "`/dest/pfad/zu/source/foo`".

| Tipp
rsync(8) und GNU cp(1) unterstützen die Option "`-u`", um Dateien zu überspringen, die am Zielort neuer sind als im Quellverzeichnis.

### 10.1.5. Aufrufe für die Auswahl von Dateien

find(1) wird verwendet, um Dateien für Archivierungs- und Kopierbefehle auszuwählen (lesen Sie Abschnitt 10.1.3, „Aufrufe für Archivierungsoperationen“ und Abschnitt 10.1.4, „Aufrufe für Kopieroperationen“) oder xargs(1) (Näheres in Abschnitt 9.4.9, „Einen Befehl wiederholt mit einer Schleife über verschiedene Dateien ausführen“). Dies kann mit deren Befehlsargumenten noch erweitert werden.

Die grundsätzliche Syntax von find(1) kann wie folgt zusammengefasst werden:

- Seine bedingten Argumente werden von links nach rechts ausgewertet.

- Die Auswertung wird beendet, sobald ihr Resultat ermittelt wurde.

- Ein "logisches ODER" (definiert über "`-o`" zwischen den Bedingungen) hat eine niedrigere Priorität als ein "logisches UND" (das über "`-a`" oder nichts zwischen den Bedingungen definiert wird).

- Ein "logisches NICHT" (definiert über "`!`" vor der Bedingung) hat eine höhere Priorität als ein "logisches UND".

- "`-prune`" liefert immer ein logisches WAHR zurück und, falls es ein Verzeichnis ist, wird die Suche nach Dateien an diesem Punkt beendet.

- "`-name`" findet Dateien über den Anfang des Dateinamens mittels Shell-Glob-Suchmuster (lesen Sie dazu Abschnitt 1.5.6, „Shell-Glob“), findet sie aber über Metazeichen wie "`*`" und "`?`" auch bei einem führenden "`.`" (neue POSIX-Funktionalität).

- "`-regex`" findet Dateien mit vollständigem Pfad standardmäßig über Emacs-artige reguläre Ausdrücke (BRE, nähere Infos finden Sie in Abschnitt 1.6.2, „Reguläre Ausdrücke“).

- "`-size`" findet Dateien basierend auf der Dateigröße (mit einem "`+`" vor dem Wert für größer, mit einem "`-`" für kleiner).

- "`-newer`" findet Dateien, die neuer sind als in dem Argument angegeben.

- "`-print0`" liefert immer ein logisches WAHR zurück und gibt den kompletten Dateinamen (abgeschlossen durch ein Nullzeichen) auf der Standardausgabe aus.

find(1) wird oft in einem idiomatischen Stil verwendet, wie hier:

    # find /path/to \
        -xdev -regextype posix-extended \
        -type f -regex ".*\.cpio|.*~" -prune -o \
        -type d -regex ".*/\.git" -prune -o \
        -type f -size +99M -prune -o \
        -type f -newer /path/to/timestamp -print0

Das bedeutet folgendes:

1. nach allen Dateien suchen, beginnend in "`/pfad/zu`";

2. die Suche global auf das Dateisystem beschränken, in dem sie begonnen wurde, und stattdessen reguläre Ausdrücke (ERE, lesen Sie dazu Abschnitt 1.6.2, „Reguläre Ausdrücke“) verwenden;

3. Dateien ausschließen, auf die die regulären Ausdrücke "`.*\.cpio`" oder "`.*~`" zutreffen, indem die Suche abgebrochen wird;

4. Verzeichnisse ausschließen, auf die der reguläre Ausdruck "`.*/\.git`" zutrifft, indem die Suche abgebrochen wird;

5. Dateien ausschließen, die größer als 99 Megabyte (1048576 Byte) sind, indem die Suche abgebrochen wird;

6. Dateinamen ausgeben, die obige Suchkriterien erfüllen und neuer als "`/path/to/timestamp`" sind.

Bitte beachten Sie die idiomatische Verwendung von "`-prune -o`", um in obigen Beispielen Dateien auszuschließen.

| Anmerkung
Auf Unix-artigen Nicht-Debian-Systemen werden einige Optionen von find(1) unter Umständen nicht unterstützt. Versuchen Sie in diesem Fall, die Suchmethoden anzupassen und "`-print0`" durch "`-print`" zu ersetzen. Unter Umständen müssen Sie auch zugehörige Befehle anpassen.

### 10.1.6. Archivierungsmedien

Wenn Sie Speichermedien für die Sicherung wichtiger Daten suchen, sollten Sie sorgfältig deren Einschränkungen abwägen. Für eine kleine persönliche Datensicherung verwende ich CD-R und DVD-R von einem Markenhersteller und lagere die Disks in einer kühlen, dunklen, trockenen und sauberen Umgebung. (Für die professionelle Nutzung scheinen Tapes (Speicherbänder) zur Archivierung sehr beliebt zu sein.)

| Anmerkung
Ein feuerbeständiger Tresor ist gedacht für Dokumente in Papierform. Jedoch haben die meisten Speichermedien eine niedrigere Temperaturtoleranz als Papier. Ich baue auf mehrere sicher verschlüsselte Kopien, die an verschiedenen sicheren Orten aufbewahrt werden.

Optimistische Angabe der Lebensdauer von Speichermedien, gefunden im Internet (überwiegend Herstellerangaben):

- 100 Jahre und mehr: säurefreies Papier mit Tinte;

- 100 Jahre: Optische Speichermedien (CD/DVD, CD-R/DVD-R);

- 30 Jahre: Magnetische Speichermedien (Bänder, Disketten);

- 20 Jahre: Optische Medien basierend auf Phasenänderung (CD-RW).

Hierbei sind keine mechanischen Ausfälle durch Handhabung usw. berücksichtigt.

Optimistische Angabe von Schreibzyklen der Speichermedien, gefunden im Internet (überwiegend Herstellerangaben):

- 250000 Zyklen und mehr: Festplattenlaufwerk;

- 10000 Zyklen und mehr: Flash-Speicher;

- 1000 Zyklen: CD-RW/DVD-RW;

- 1 Zyklus: CD-R/DVD-R, Papier.

| Achtung
Die obigen Angaben zu Lebensdauer und Schreibzyklen sollten nicht für Entscheidungen bezüglich kritischer Datenspeicherung herangezogen werden. Bitte konsultieren Sie in diesem Fall die spezifischen Produktinformationen des Herstellers.

| Tipp
Da CD-R/DVD-R und Papier nur einmal beschrieben werden können, schützen sie von Natur aus vor dem versehentlichen Datenverlust durch Überschreiben. Dies ist ein Vorteil!

| Tipp
Wenn Sie eine schnelle und wiederholte Sicherung großer Datenmengen benötigen, könnte eine Festplatte in einem fernen Rechner, verbunden über eine schnelle Internetverbindung, die einzige realistische Option sein.

| Tipp
Wenn Sie wiederbeschreibbare Medien für Ihre Backups verwenden, könnte es eine gute Idee sein, Dateisysteme wie btrfs oder zfs zu nutzen, die nur-lesbare Schnappschüsse unterstützen.

### 10.1.7. Wechseldatenträger

Wechseldatenträger können folgende Geräte sein:

- USB-Flash-Speicher (USB-Stick);

- Festplattenlaufwerk;

- Optisches Laufwerk (CD/DVD/BD);

- Digitalkamera;

- Digitaler Mediaplayer.

Sie können über eine dieser Möglichkeiten verbunden sein:

- USB;

- IEEE 1394 / FireWire;

- PC Card.

Moderne Arbeitsplatzumgebungen wie GNOME und KDE können diese Wechseldatenträger auch ohne einen entsprechenden "`/etc/fstab`"-Eintrag automatisiert einbinden.

- Das `udisks2`-Paket enthält einen Daemon und dazugehörige Hilfsprogramme, um diese Datenträger automatisch einzubinden und zu trennen.

- D-bus erzeugt Ereignisse, um automatische Prozesse anzustoßen.

- PolicyKit stellt die erforderlichen Berechtigungen bereit.

| Tipp
Automatisch eingebundene Geräte haben eventuell die mount-Option "`uhelper=`", die von umount(8) genutzt wird.

| Tipp
In modernen Arbeitsplatzumgebungen funktioniert das automatische Einbinden von Laufwerken nur, wenn diese Geräte nicht in "`/etc/fstab`" aufgelistet sind.

Der Einbindungspunkt wird in modernen Umgebungen in der Form "`/media/benutzername/laufwerksname`" abgebildet; die Laufwerksbezeichnung (manchmal auch als Disk-Label bezeichnet) kann wie folgt angepasst werden:

- mlabel(1) bei FAT-Dateisystemen;

- genisoimage(1) mit der Option "`-V`" bei ISO9660-Dateisystemen;

- tune2fs(1) mit der Option "`-L`" bei ext2-/ext3-/ext4-Dateisystemen.

| Tipp
Die verwendete Zeichenkodierung muss unter Umständen als mount-Option angegeben werden (lesen Sie dazu Abschnitt 8.1.3, „Dateinamenkodierung“).

| Tipp
Die Verwendung des grafischen GUI-Menüs zur Trennung eines eingebundenen Dateisystems könnte auch dessen dynamisch erzeugte Gerätedatei (z.B. "`/dev/sdc`" entfernen. Falls Sie diese Gerätedatei erhalten möchten, trennen Sie die Einbindung mit dem umount(8)-Befehl von einem Shell-Prompt.

### 10.1.8. Dateisystemauswahl für den Datenaustausch

Um Daten mit anderen Systemen über Wechseldatenträger auszutauschen, sollten Sie diese mit einem Dateisystem formatieren, das von beiden Systemen unterstützt wird.

| Anmerkung
Statements on hard disk (HDD) are applicable to other storage devices such as SSD / USB flash drive / Memory card / ... . Replace device names in examples such as `/dev/sda` with applicable device names `/dev/nvme0`, `/dev/mmcblk0`, ... .

Tabelle 10.3. Liste von Dateisystemen für Wechseldatenträger mit typischen Anwendungsszenarien

Dateisystemname | Typisches Anwendungsszenario
--- | ---
FAT12 | Plattformübergreifender Datenaustausch mittels Diskette (<32 MiB)
FAT16 | Plattformübergreifender Datenaustausch mittels kleiner festplatten-ähnlicher Geräte (<2 GiB)
FAT32 | Plattformübergreifender Datenaustausch mittels großer festplatten-ähnlicher Geräte (<8 TiB, unterstützt von Systemen neuer als MS Windows95 OSR2)
exFAT | Plattformübergreifender Datenaustausch mittels großer festplatten-ähnlicher Geräte (<512 TiB, unterstützt von WindowsXP, Mac OS X Snow Leopard 10.6.5 und Linux-Kernel ab 5.4)
NTFS | Plattformübergreifender Datenaustausch mittels großer festplatten-ähnlicher Geräte (nativ unterstützt von MS Windows NT und späteren Versionen; auch unterstützt durch NTFS-3G via FUSE unter Linux)
ISO9660 | Plattformübergreifender Austausch statischer Daten mittels CD-R und DVD+/-R
UDF | inkrementelles Schreiben von Daten auf CD-R und DVD+/-R (neu)
MINIX | platzsparendes Speichern von Unix-Daten auf Diskette
ext2 | Datenaustausch mit älteren Linux-Systemen auf festplatten-ähnlichen Geräten
ext3 | Datenaustausch mit älteren Linux-Systemen auf festplatten-ähnlichen Geräten
ext4 | Datenaustausch mit aktuellen Linux-Systemen auf festplatten-ähnlichen Geräten
btrfs | Datenaustausch mit aktuellen Linux-Systemen auf festplatten-ähnlichen Geräten mit nur-lesbaren Schnappschüssen

| Tipp
Details zum plattformübergreifenden Datenaustausch mit Verschlüsselung auf Geräteebene finden Sie in Abschnitt 9.9.1, „Verschlüsselung von Wechseldatenträgern mit dm-crypt/LUKS“.

Das FAT-Dateisystem wird von nahezu allen modernen Dateisystemen unterstützt und ist für den Datenaustausch über Wechseldatenträger sehr nützlich.

Wenn Sie Geräte wie externe Festplatten für den plattformübergreifenden Datenaustausch mit dem FAT-Dateisystem formatieren, sollten die folgenden Varianten eine sichere Wahl sein:

- Partitionieren Sie das Medium mit fdisk(8), cfdisk(8) oder parted(8) (lesen Sie dazu Abschnitt 9.6.2, „Konfiguration der Festplattenpartitionen“) mit einer einzigen primären Partition und markieren Sie sie wie folgt:

  - Typ "6" (FAT16) für Medien kleiner als 2 GB;

  - Typ "c" (FAT32, LBA) für größere Medien.

- Formatieren der primären Partition mit mkfs.vfat(8) wie folgt:

  - einfach über den Gerätenamen, z.B. "`/dev/sda1`" für FAT16;

  - über die explizite Option und den Gerätenamen, z.B. "`-F 32 /dev/sda1`" für FAT32.

Wenn das FAT- oder ISO9660-Dateisystem für den Dateiaustausch verwendet wird, sollte folgendes eine sichere Variante sein:

- archivieren der Dateien in eine Archivdatei mittels tar(1) oder cpio(1), um die langen Dateinamen, symbolischen Links, originalen Unix-Dateiberechtigungen und Benutzerinformationen zu erhalten;

- splitten der Archivdatei in Stücke kleiner als 2 GiB mittels split(1), um so die Beschränkung der Dateigröße umgehen zu können;

- verschlüsseln der Archivdatei, um den Inhalt vor unberechtigtem Zugriff zu schützen.

| Anmerkung
Bei dem FAT-Dateisystem liegt - begründet durch sein Design - die maximale Dateigröße bei `(2^32 - 1) Byte = (4 GiB - 1 Byte)`. Bei einigen Anwendungen auf älteren 32-Bit-Betriebssystemen war die maximale Dateigröße sogar noch kleiner: `(2^31 - 1) Byte = (2 GiB - 1 Byte)`. Debian ist von letzterem nicht betroffen.

| Anmerkung
Microsoft selbst empfiehlt FAT nicht für Laufwerke oder Partitionen über 200 MB Größe. Microsoft hebt die Nachteile wie ineffiziente Speicherplatznutzung in seiner "Übersicht über die Dateisysteme FAT, HPFS und NTFS" hervor. Natürlich sollten wir für Linux normalerweise das ext4-Dateisystem nutzen.

| Tipp
Mehr Informationen über Dateisysteme und Dateisystemzugriffe finden Sie im "Filesystems HOWTO" (Englisch).

### 10.1.9. Datenaustausch über das Netzwerk

Wenn Sie Daten mit anderen Systemen über das Netzwerk austauschen, sollten Sie allgemein gängige Dienste verwenden. Hier einige Hinweise:

Tabelle 10.4. Liste von Netzwerkdiensten mit typischen Anwendungsszenarien

Netzwerkdienst | Beschreibung des typischen Anwendungsszenarios
--- | ---
SMB/CIFS - über Netzwerk mit Samba eingebundenes Dateisystem | Datenaustausch über "Microsoft Windows Network", Näheres in smb.conf(5) und The Official Samba 3.x.x HOWTO and Reference Guide oder im `samba-doc`-Paket
NFS - über Netzwerk mittels Linux-Kernel eingebundenes Dateisystem | Datenaustausch über "Unix/Linux Network", Näheres in exports(5) und im Linux NFS-HOWTO
HTTP-Dienst | Datenaustausch zwischen Web-Server/-Client
HTTPS-Dienst | Datenaustausch zwischen Web-Server/-Client mit verschlüsseltem Secure Sockets Layer (SSL) oder Transport Layer Security (TLS)
FTP-Dienst | Datenaustausch zwischen FTP-Server/-Client

Obwohl Dateisysteme, die über solche Netzwerk-gestützten Transfermethoden eingebunden sind, für den Datenaustausch sehr praktisch sind, könnten Sie unsicher sein. Die genutzte Netzwerkverbindung muss wie folgt abgesichert sein:

- verschlüsseln Sie sie mit SSL/TLS;

- tunneln Sie sie via SSH;

- tunneln Sie sie via VPN;

- schränken Sie den Zugriff über eine Firewall ein.

Lesen Sie auch Abschnitt 6.5, „Weitere Netzwerkanwendungs-Server“ und Abschnitt 6.6, „Weitere Netzwerkanwendungs-Clients“.

## 10.2. Datensicherung und -wiederherstellung

Wir alle wissen, dass Computer manchmal defekt sein können oder menschliche Fehler System- und Datenausfälle verursachen. Aktionen zur Datensicherung und -wiederherstellung sind unverzichtbarer Teil einer erfolgreichen Systemadministration. Alle möglichen Fehlervarianten werden Sie eines Tages ereilen.

| Tipp
Halten Sie Ihr Datensicherungssystem einfach und führen Sie häufig Sicherungen durch. Aktuelle Sicherungen von seinen Daten zu haben ist wichtiger als die technische Qualität der Sicherungsmethodik.

### 10.2.1. Richtlinien für Datensicherung und -wiederherstellung

Es gibt drei Schlüsselfaktoren, die letztendig die Sicherungs- und Wiederherstellungsstrategie bestimmen:

1. Zu wissen, was man sichern und wiederherstellen muss:

   - Daten, die direkt von Ihnen selbst erstellt wurden: Daten in "`~/`";

   - Daten, die von Anwendungen, die Sie verwenden, erstellt wurden: Daten in "`/var/`" (außer "`/var/cache/`", "`/var/run/`" und "`/var/tmp/`");

   - Systemkonfigurationsdateien: Daten in "`/etc/`";

   - Lokale Programme: Daten in "`/usr/local/`" oder "`/opt/`";

   - Informationen zur Systeminstallation: Aufzeichnungen über wichtige Schritte (Partitionierung, …) in einfacher Textform;

   - Daten, von denen Sie wissen, dass sie wichtig sind, bestätigt durch im Vornherein versuchsweise durchgeführte Wiederherstellungsoperationen.

     - Cron-Job als Benutzerprozess: Dateien im Verzeichnis "`/var/spool/cron/crontabs`"; anschließend cron(8) neu starten. Informationen über cron(8) und crontab(1) in Abschnitt 9.4.14, „Regelmäßige Aufgaben planen“.

     - Systemd Timer-Jobs als Benutzerprozess: Dateien im Verzeichnis "`~/.config/systemd/user`". Näheres in systemd.timer(5) und systemd.service(5).

     - Autostart-Jobs als Benutzerprozess: Dateien im Verzeichnis "`~/.config/autostart`". Siehe Desktop Application Autostart Specification (Englisch).

2. Wissen, wie Sie Daten sichern und wiederherstellen:

   - Sicheres Speichern von Daten: geschützt vor Überschreiben und Systemausfällen;

   - Häufige Datensicherungen: Sicherungen planen;

   - Redundante Datensicherungen: Spiegeln der Sicherungsdateien;

   - Idiotensicheres Vorgehen: Sicherung durch einen einfachen Befehl.

3. Bewertung der entstehenden Risiken und Kosten:

   - Risiko, falls die Daten verloren gehen;

     - Daten sollten zumindest auf verschiedenen Festplattenpartitionen, besser sogar auf unterschiedlichen Laufwerken und Maschinen liegen, um unanfällig gegen Dateisystembeschädigungen zu sein. Wichtige Daten sollten am besten auf einem schreibgeschützten Dateisystem abgelegt werden. [4]

   - Risiko, falls die Daten öffentlich werden;

     - Sensible Identitätsdaten wie "`/etc/ssh/ssh_host_*_key`", "`~/.gnupg/*`", "`~/.ssh/*`", "`~/.local/share/keyrings/*`", "`/etc/passwd`", "`/etc/shadow`", "`popularity-contest.conf`", "`/etc/ppp/pap-secrets`" oder "`/etc/exim4/passwd.client`" sollten nur verschlüsselt gesichert werden. [5] (Siehe auch Abschnitt 9.9, „Tipps zur Datenverschlüsselung“.)

     - Fügen Sie niemals System-Login-Passwörter oder Verschlüsselungs-Passphrasen in ein Skript ein, nicht einmal auf einem System, dem Sie vertrauen. (Siehe dazu Abschnitt 10.3.6, „Passwort-Schlüsselbund“.)

   - Mögliche Ausfälle und deren Wahrscheinlichkeit.

     - Hardware-Defekte (speziell bei Festplatten) sind wahrscheinlich

     - Dateisysteme könnten beschädigt werden und enthaltene Daten gehen verloren

     - Fernen Speichersystemen (Cloud, ...) können Sie aufgrund von Sicherheitslücken nicht trauen

     - Ein schwacher Passwortschutz kann leicht kompromittiert werden

     - Systeme zur Festlegung von Dateiberechtigungen können kompromittiert werden

   - Für die Sicherung benötigte Ressourcen: Personen, Hardware, Software, …;

     - Automatisch ablaufende Backups über cron-Jobs oder systemd-timer-Jobs

| Tipp
Sie können die debconf-Konfigurationsdaten mit "`debconf-set-selections debconf-selections`" wiederherstellen und die dpkg-Paketauswahl mit "`dpkg --set-selection <dpkg-selections.list`".

| Anmerkung
Machen Sie keine Sicherungen von den Pseudo-Dateisystemen in `/proc`, `/sys`, `/tmp` und `/run` (Näheres dazu in Abschnitt 1.2.12, „procfs und sysfs“ und Abschnitt 1.2.13, „tmpfs“). Dies sind absolut nutzlose Daten, außer Sie genau wissen, was Sie tun.

| Anmerkung
Sie sollten eventuell einige Anwendungs-Daemons wie den MTA (lesen Sie dazu Abschnitt 6.2.4, „Mail Transfer Agent (MTA)“) beenden, während Sie die Datensicherung durchführen.

### 10.2.2. Programmsammlungen für Datensicherungsaufgaben

Hier eine Auswahl erwähnenswerter, im Debian-System verfügbarer Datensicherungsprogramme:

Tabelle 10.5. Liste von Datensicherungsprogrammen

Paket | Popcon | Größe | Beschreibung
--- | --- | --- | ---
`bacula-common` | V:6.3, I:7.1 | 2501 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - gemeinsame Hilfsdateien
`bacula-client` | V:0.3, I:1.8 | 199 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Client-Metapaket
`bacula-console` | V:0.6, I:2.1 | 112 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Textkonsole
`bacula-server` | I:0.61 | 199 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Server-Metapaket
`amanda-common` | V:0.6, I:2.2 | 9851 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Bibliotheken)
`amanda-client` | V:0.6, I:2.2 | 1099 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Client)
`amanda-server` | V:0.12, I:0.22 | 1093 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Server)
`backuppc` | V:1.4, I:1.7 | 3088 | BackupPC ist ein leistungsfähiges System der Enterprise-Klasse zur Datensicherung von PCs (festplatten-basiert)
`duplicity` | V:5, I:46 | 2679 | Inkrementelles Backup (auch von fern)
`deja-dup` | V:28, I:42 | 5274 | GUI-Frontend für duplicity
`borgbackup` | V:13, I:28 | 3532 | deduplizierendes Backup (auch von fern)
`borgmatic` | V:3.2, I:4.5 | 946 | borgbackup-Hilfsprogramm
`rdiff-backup` | V:2.2, I:6.5 | 1207 | Inkrementelles Backup (auch von fern)
`restic` | V:7, I:14 | 41617 | Inkrementelles Backup (auch von fern)
`backupninja` | V:2.1, I:2.6 | 360 | ressourcenschonendes, erweiterbares Meta-Backup-System
`slbackup` | V:0.09, I:0.12 | 147 | Inkrementelles Backup (auch von fern)
`backup-manager` | V:0.43, I:0.75 | 573 | befehlszeilen-basiertes Datensicherungs-Werkzeug
`backup2l` | V:0.34, I:0.47 | 110 | wartungsarmes Sicherungs-/Wiederherstellungsprogramm für mount-fähige Medien (festplatten-basiert)

Datensicherungs-Werkzeuge haben alle ihren speziellen Fokus:

- Mondo Rescue ist ein Backup-System, das die schnelle Wiederherstellung eines vollständigen Systems von CD/DVD ermöglicht, ohne dass dabei die normalen Systeminstallations-Prozesse durchlaufen werden müssen.

- Bacula, Amanda und BackupPC sind voll ausgestattete Backup-Lösungen, die auf die regelmäßige Datensicherung über Netzwerk fokussiert sind.

- Duplicity und Borg sind einfache Backup-Werkzeuge für typische Arbeitsplatzrechner.

### 10.2.3. Backup-Tipps

Für einen Arbeitsplatzrechner könnte eine voll ausgestattete, für Server-Umgebungen entwickelte Backup-Lösung unpassend sein. Gleichzeitig könnten aber vorhandene Backup-Werkzeuge für Arbeitsplatzrechner auch Schwächen haben.

Hier einige Tipps, um Backups zu erleichtern, bei gleichzeitig mimimalem Aufwand. Diese Techniken können bei allen Backup-Programmen Anwendung finden.

Für Demonstrationszwecke gehen wir hier davon aus, dass der primäre Benutzer- und Gruppenname `penguin` ist. Wir erstellen ein Beipiel für ein Backup- und Schnappschuss-Skript namens "`/usr/local/bin/bkss.sh`" wie folgt:

    #!/bin/sh -e
    SRC="$1" # source data path
    DSTFS="$2" # backup destination filesystem path
    DSTSV="$3" # backup destination subvolume name
    DSTSS="${DSTFS}/${DSTSV}-snapshot" # snapshot destination path
    if [ "$(stat -f -c %T "$DSTFS")" != "btrfs" ]; then
      echo "E: $DESTFS needs to be formatted to btrfs" >&2 ; exit 1
    fi
    MSGID=$(notify-send -p "bkup.sh $DSTSV" "in progress ...")
    if [ ! -d "$DSTFS/$DSTSV" ]; then
      btrfs subvolume create "$DSTFS/$DSTSV"
      mkdir -p "$DSTSS"
    fi
    rsync -aHxS --delete --mkpath "${SRC}/" "${DSTFS}/${DSTSV}"
    btrfs subvolume snapshot -r "${DSTFS}/${DSTSV}" ${DSTSS}/$(date -u --iso=min)
    notify-send -r "$MSGID" "bkup.sh $DSTSV" "finished!"

Hier wird nur das Basiswerkzeug rsync(1) genutzt, um das System-Backup zu vereinfachen, und der Speicherplatz wird durch Btrfs effizient genutzt.

| Tipp
Zu Ihrer Information: der Autor nutzt ein eigenes, ähnliches Shell-Skript "bss: Btrfs Subvolume Snapshot Utility" für seinen Arbeitsplatzrechner.

#### 10.2.3.1. Grafische Backup-Software

Hier ein Beispiel zur Einrichtung einer grafischen Ein-Klick Backup-Lösung.

- Bereiten Sie einen USB-Massenspeicher vor, der für das Backup genutzt wird.

  - Formatieren Sie den USB-Speicher mit einer Partition als btrfs mit einem Label namens "`BKUP`". Dies kann auch verschlüsselt sein (siehe Abschnitt 9.9.1, „Verschlüsselung von Wechseldatenträgern mit dm-crypt/LUKS“).

  - Schließen Sie ihn an Ihr System an. Das Arbeitsplatzsystem sollte ihn automatisch als "`/media/penguin/BKUP`" einbinden.

  - Führen Sie "`sudo chown penguin:penguin /media/penguin/BKUP`" aus, um ihn für den Benutzer schreibbar zu machen.

- Erstellen Sie "`~/.local/share/applications/BKUP.desktop`" (mit den Techniken unter Abschnitt 9.4.10, „Ein Programm aus der grafischen Oberfläche heraus starten“), wie hier:

      [Desktop Entry]
      Name=bkss
      Comment=Backup and snapshot of ~/Documents
      Exec=/usr/local/bin/bkss.sh /home/penguin/Documents /media/penguin/BKUP Documents
      Type=Application

Bei jedem Klick werden Ihre Daten aus "`~/Documents`" auf den USB-Speicher gesichert und es wird ein btrfs-Schnappschuss (nur lesbar) erzeugt.

#### 10.2.3.2. Automatisches Backup, durch ein mount-Ereignis ausgelöst

Hier ist ein Beispiel, wie Sie ein automatisches Backup einrichten, das durch ein mount-Ereignnis ausgelöst wird.

- Bereiten Sie einen USB-Massenspeicher vor, der für das Backup genutzt wird (siehe Abschnitt 10.2.3.1, „Grafische Backup-Software“).

- Erstellen Sie eine systemd Service-Unit-Datei "`~/.config/systemd/user/back-BKUP.service`" wie hier:

      [Unit]
      Description=USB Disk backup
      Requires=media-%u-BKUP.mount
      After=media-%u-BKUP.mount

      [Service]
      ExecStart=/usr/local/bin/bkss.sh %h/Documents /media/%u/BKUP Documents
      StandardOutput=append:%h/.cache/systemd-snap.log
      StandardError=append:%h/.cache/systemd-snap.log

      [Install]
      WantedBy=media-%u-BKUP.mount

- Aktivieren Sie diese systemd-Unit-Konfiguration mit:

       $ systemctl --user enable bkup-BKUP.service

Bei jedem mount-Ereignis werden Ihre Daten aus "`~/Documents`" auf den USB-Speicher gesichert und ein btrfs-Schnappschuss (nur lesbar) wird erstellt.

Hierbei können Sie die Namen aller systemd-mount-Units, die systemd aktuell im Speicher hat, anzeigen lassen mit "`systemctl --user list-units --type=mount`".

#### 10.2.3.3. Automatisches Backup, durch ein timer-Ereignis ausgelöst

Hier ein Beispiel für ein Backup, das automatisch durch ein timer-Ereignis ausgelöst wird.

- Bereiten Sie einen USB-Massenspeicher vor, der für das Backup genutzt wird (siehe Abschnitt 10.2.3.1, „Grafische Backup-Software“).

- Erstellen Sie eine systemd timer-Unit-Datei "`~/.config/systemd/user/snap-Documents.timer`" wie hier:

      [Unit]
      Description=Run btrfs subvolume snapshot on timer
      Documentation=man:btrfs(1)

      [Timer]
      OnStartupSec=30
      OnUnitInactiveSec=900

      [Install]
      WantedBy=timers.target

- Erstellen Sie eine systemd Service-Unit-Datei "`~/.config/systemd/user/snap-Documents.service`":

      [Unit]
      Description=Run btrfs subvolume snapshot
      Documentation=man:btrfs(1)

      [Service]
      Type=oneshot
      Nice=15
      ExecStart=/usr/local/bin/bkss.sh %h/Documents /media/%u/BKUP Documents
      IOSchedulingClass=idle
      CPUSchedulingPolicy=idle
      StandardOutput=append:%h/.cache/systemd-snap.log
      StandardError=append:%h/.cache/systemd-snap.log

- Aktivieren Sie diese systemd-Unit-Konfiguration mit:

       $ systemctl --user enable snap-Documents.timer

Bei jedem timer-Ereignis werden Ihre Daten aus "`~/Documents`" auf den USB-Speicher gesichert und ein btrfs-Schnappschuss (nur lesbar) wird erstellt.

Hierbei können Sie die Namen aller systemd-timer-Units, die systemd aktuell im Speicher hat, anzeigen lassen mit "`systemctl --user list-units --type=timer`".

Für ein modernes Arbeitsplatzsystem kann dieser systemd-Ansatz einen feiner dosierten Ansatz bieten als die traditionellen Unix-Lösungen mit at(1), cron(8) oder anacron(8).

## 10.3. Datensicherheits-Infrastruktur

Die Sicherheitsinfrastruktur für Ihre Daten wird durch eine Kombination verschiedener Programme gewährleistet: Verschlüsselungswerkzeug, Message-Digest-Werkzeug und Signaturwerkzeug.

Tabelle 10.6. Liste von Werkzeugen für die Datensicherheits-Infrastruktur

Paket | Popcon | Größe | Befehl | Beschreibung
--- | --- | --- | --- | ---
`gnupg` | V:406, I:864 | 465 | gpg(1) | GNU Privacy Guard - OpenPGP Verschlüsselungs- und Signaturwerkzeug
`gpgv` | V:219, I:932 | 577 | gpgv(1) | GNU Privacy Guard - OpenPGP Werkzeug zur Verifizierung von Signaturen
`sq` | V:1, I:30 | 23926 | sq(1) | Sequoia-PGP - OpenPGP Verschlüsselungs- und Signaturwerkzeug
`sqv` | V:443, I:518 | 1855 | sqv(1) | Sequoia-PGP - OpenPGP - Werkzeug zur Verifizierung von Signaturen
`paperkey` | V:1, I:11 | 58 | paperkey(1) | lediglich die geheimen Informationen aus geheimen OpenPGP-Schlüsseln extrahieren
`cryptsetup` | V:35, I:80 | 465 | cryptsetup(8), … | Hilfsprogramme für die dm-crypt Blockgeräte-Verschlüsselung (enthält Unterstützung für LUKS)
`coreutils` | V:910, I:1000 | 17994 | md5sum(1) | MD5-Message-Digest (Prüfsummen) berechnen und überprüfen
`coreutils` | V:910, I:1000 | 17994 | sha1sum(1) | SHA1-Message-Digest (Prüfsummen) berechnen und überprüfen
`openssl` | V:855, I:997 | 2532 | `openssl`(1ssl) | Message-Digest mit "`openssl dgst`" berechnen (OpenSSL)
`libsecret-tools` | V:1, I:12 | 45 | secret-tool(1) | Speichern und Empfangen von Passwörtern (CLI)
`seahorse` | V:73, I:258 | 7999 | seahorse(1) | Schlüsselverwaltungs-Werkzeug (GNOME)

In Abschnitt 9.9, „Tipps zur Datenverschlüsselung“ finden Sie Infos über dm-crypt und fscrypt, die automatische Datenverschlüsselungs-Infrastrukturen über Linux-Kernelmodule implementieren.

### 10.3.1. Schlüsselverwaltung für GnuPG

Hier einige Befehle für die grundlegende Schlüsselverwaltung mit GNU Privacy Guard:

Tabelle 10.7. Liste von GNU-Privacy-Guard-Befehlen für die Schlüsselverwaltung

Befehl | Beschreibung
--- | ---
`gpg --gen-key` | einen neuen Schlüssel generieren
`gpg --gen-revoke meine_Nutzer_ID` | einen Widerrufschlüssel (revoke key) für meine_Nutzer_ID generieren
`gpg --edit-key Nutzer_ID` | Schlüssel interaktiv editieren, "help" eingeben für weitere Hilfe
`gpg -o datei --export` | export all public keys to file
`gpg -o file --export-secret-keys` | export all private key to file
`gpg --import datei` | alle Schlüssel aus datei importieren
`gpg --send-keys Nutzer_ID` | Schlüssel von Nutzer_ID zum Schlüsselserver übertragen
`gpg --recv-keys Nutzer_ID` | Schlüssel von Nutzer_ID vom Schlüsselserver empfangen
`gpg --list-keys Nutzer_ID` | Schlüssel von Nutzer_ID auflisten
`gpg --list-sigs user_ID` | Signaturen von Nutzer_ID auflisten
`gpg --check-sigs Nutzer_ID` | Signaturen von Nutzer_ID überprüfen
`gpg --fingerprint Nutzer_ID` | Fingerabdruck von Nutzer_ID überprüfen
`gpg --refresh-keys` | lokalen Schlüsselring aktualisieren

Hier die Bedeutung des Vertrauenscodes:

Tabelle 10.8. Liste der Bedeutungen des Vertrauenscodes

Code | Beschreibung des Vertrauenscodes
--- | ---
`-` | Kein Besitzervertrauen zugewiesen / noch nicht berechnet
`e` | Vertrauensberechnung fehlgeschlagen
`q` | nicht genügend Informationen für Berechnung
`n` | diesem Schlüssel niemals vertrauen
`m` | gerade noch vertrauenswert
`f` | voll vertrauenswert
`u` | absolut vertrauenswert

The following generates my key "`9563FC29932C409F1A77F9C1AB8A1522D8234C6A`".

    $ gpg --gen-key
    gpg (GnuPG) 2.4.7; Copyright (C) 2024 g10 Code GmbH
    ...
    GnuPG needs to construct a user ID to identify your key.

    Real name: Osamu Aoki
    Email address: osamu@debian.org
    You selected this USER-ID:
        "Osamu Aoki <osamu@debian.org>"

    Change (N)ame, (E)mail, or (O)kay/(Q)uit? o
    ...
    public and secret key created and signed.

    pub   ed25519 2026-02-14 [SC] [expires: 2029-02-13]
          9563FC29932C409F1A77F9C1AB8A1522D8234C6A
    uid                      Osamu Aoki <osamu@debian.org>
    sub   cv25519 2026-02-14 [E] [expires: 2029-02-13]

Folgendes lädt meinen Schlüssel "`9563FC29932C409F1A77F9C1AB8A1522D8234C6A`" auf den populären Schlüsselserver "`hkp://keys.gnupg.net`" hoch:

    $ gpg --keyserver hkp://keys.gnupg.net --send-keys 9563FC29932C409F1A77F9C1AB8A1522D8234C6A

Ein gutes Standard-Schlüsselserver-Setup in "`~/.gnupg/gpg.conf`" (oder dem alten Ort "`~/.gnupg/options`") enthält folgendes:

    keyserver hkp://keys.gnupg.net

Mit dem folgenden Befehl beziehen Sie unbekannte Schlüssel vom Schlüsselserver:

    $ gpg --list-sigs --with-colons | grep '^sig.*\[User ID not found\]' |\
              cut -d ':' -f 5| sort | uniq | xargs gpg --recv-keys

Es gab einen Fehler in OpenPGP Public Key Server (Versionen vor 0.9.6), durch den Schlüssel mit mehr als zwei Unterschlüsseln korrumpiert wurden. Das neue `gnupg`-Paket (>1.2.1-2) kann mit diesen korrumpierten Unterschlüsseln umgehen. Lesen Sie in gpg(1) den Abschnitt zur Option "`--repair-pks-subkey-bug`".

Use of SHA-1 for hash has been deprecated. If your old RSA based openPGP key uses SHA-1 for hash, fix it using FixKeyWithSha1.

| Tipp
The sq(1) and sqv(1) commands are an alternative set of openPGP commands. See sq user documentation and A Practical Introduction to using sq, Sequoia PGP’s CLI.

### 10.3.2. Verwendung von GnuPG mit Dateien

Hier einige Beispiele für die Verwendung von GNU Privacy Guard mit Dateien:

Tabelle 10.9. Liste von GNU-Privacy-Guard-Befehlen mit Dateien

Befehl | Beschreibung
--- | ---
`gpg -a -s datei` | Signieren von datei in die ASCII-bewehrte datei.asc
`gpg --armor --sign datei` | "
`gpg --clearsign datei` | Signieren einer Nachricht mit Klartextsignatur
`gpg --clearsign datei|mail foo@example.org` | Versenden einer Nachricht mit Klartextsignatur an `foo@example.org`
`gpg --clearsign --not-dash-escaped patch-datei` | Klartext-signieren von patch-datei
`gpg --verify datei` | eine klartextsignierte datei verifizieren
`gpg -o datei.sig -b datei` | Erzeugen einer losgelösten Signatur
`gpg -o datei.sig --detach-sign datei` | "
`gpg --verify datei.sig datei` | Verifizieren von datei mit datei.sig
`gpg -o crypt_datei.gpg -r name -e datei` | Verschlüsselung mit öffentlichem Schlüssel für name von datei in Binärdatei crypt_datei.pgp
`gpg -o crypt_datei.gpg --recipient name --encrypt datei` | "
`gpg -o crypt_datei.asc -a -r name -e datei` | Verschlüsselung mit öffentlichem Schlüssel für name von datei in ASCII-bewehrte Datei crypt_datei.pgp
`gpg -o crypt_datei.gpg -c datei` | symmetrische Verschlüsselung von "datei" in crypt_datei.gpg
`gpg -o crypt_datei.gpg --symmetric datei` | "
`gpg -o crypt_datei.asc -a -c datei` | symmetrische Verschlüsselung für name von datei in ASCII-bewehrte Datei crypt_datei.asc
`gpg -o datei -d crypt_datei.gpg -r name` | Entschlüsselung
`gpg -o datei --decrypt crypt_datei.gpg` | "

### 10.3.3. Verwendung von GnuPG mit Mutt

Fügen Sie Folgendes zu "`~/.muttrc`" hinzu, um zu verhindern, dass das langsame GnuPG automatisch gestartet wird, während es durch Drücken von "`S`" im Indexmenü händisch gestartet werden kann:

    macro index S ":toggle pgp_verify_sig\n"
    set pgp_verify_sig=no

### 10.3.4. Verwendung von GnuPG mit Vim

Das `gnupg`-Plugin ermöglicht Ihnen, GnuPG für Dateien mit den Endungen "`.gpg`", "`.asc`" und "`.pgp`" transparent laufen zu lassen: [6]

    $ sudo aptitude install vim-scripts
    $ echo "packadd! gnupg" >> ~/.vim/vimrc

### 10.3.5. Die MD5-Prüfsumme

md5sum(1) enthält ein Werkzeug, um über die in RFC1321 beschriebene Methode eine Digest-Datei zu erzeugen und jede Datei darüber zu verifizieren:

    $ md5sum foo bar >baz.md5
    $ cat baz.md5
    d3b07384d113edec49eaa6238ad5ff00  foo
    c157a79031e1c40f85931829bc5fc552  bar
    $ md5sum -c baz.md5
    foo: OK
    bar: OK

| Anmerkung
Die Berechnung der MD5-Prüfsumme ist weniger CPU-intensiv als die für die krypthographische Signatur durch GNU Privacy Guard (GnuPG). Üblicherweise ist nur die Digest-Datei der obersten Ebene (z.B. das Wurzelverzeichnis eines Verzeichnisbaums) kryptographisch signiert, um die Datenintegrität sicherzustellen.

### 10.3.6. Passwort-Schlüsselbund

Im GNOME-System verwaltet das grafische Hilfsprogramm seahorse(1) Passwörter und speichert sie sicher im Schlüsselbund `~/.local/share/keyrings/*`.

secret-tool(1) kann Passwörter über die Befehslzeile in diesem Schlüsselbund ablegen.

Lassen Sie uns die Passphrase für ein LUKS/dm-crypt-verschlüsseltes Festplatten-Image speichern:

    $ secret-tool store --label='LUKS passphrase for disk.img' LUKS my_disk.img
    Password: ********

Dieses gespeicherte Passwort kann ausgelesen und an andere Programme wie z.B. cryptsetup(8) übergegeen werden:

    $ secret-tool lookup LUKS my_disk.img | \
      cryptsetup open disk.img disk_img --type luks --keyring -
    $ sudo mount /dev/mapper/disk_img /mnt

| Tipp
Wann immer Sie ein Passwort in einem Skript angeben müssen, verwenden Sie `secret-tool` und vermeiden Sie es, die Passphrase fest in dem Skript zu hinterlegen.

## 10.4. Werkzeuge zur Quellcode-Zusammenführung (merge)

Es gibt viele Werkzeuge für die Zusammenführung von Quellcode. Folgende Befehle haben meine Aufmerksamkeit erregt:

Tabelle 10.10. Liste von Werkzeugen zur Quellcode-Zusammenführung

Paket | Popcon | Größe | Befehl | Beschreibung
--- | --- | --- | --- | ---
`patch` | V:107, I:729 | 242 | patch(1) | eine diff-Datei auf ein Original anwenden
`vim` | V:81, I:342 | 4164 | vimdiff(1) | zwei Dateien nebeneinander in vim vergleichen
`imediff` | V:0.02, I:0.28 | 329 | imediff(1) | interaktives Werkzeug für Zwei-/Dreiwege-Zusammenführung mit Vollbildschirmmodus
`meld` | V:5, I:24 | 3992 | meld(1) | vergleichen und zusammenführen von Dateien (GTK)
`wiggle` | V:0.02, I:0.14 | 175 | wiggle(1) | zurückgewiesene Patches anwenden
`diffutils` | V:895, I:998 | 1768 | diff(1) | Dateien Zeile für Zeile vergleichen
`diffutils` | V:895, I:998 | 1768 | diff3(1) | drei Dateien Zeile für Zeile vergleichen und zusammenführen
`quilt` | V:2, I:18 | 880 | quilt(1) | Serien von Patches verwalten
`wdiff` | V:6, I:40 | 651 | wdiff(1) | Wort-für-Wort-Unterschiede zwischen Textdateien anzeigen
`diffstat` | V:9, I:97 | 79 | diffstat(1) | eine Grafik der Veränderungen für eine diff-Datei erstellen
`patchutils` | V:12, I:96 | 269 | combinediff(1) | einen kumulativen Patch aus zwei inkrementellen Patches erzeugen
`patchutils` | V:12, I:96 | 269 | dehtmldiff(1) | ein Diff aus einer HTML-Seite extrahieren
`patchutils` | V:12, I:96 | 269 | filterdiff(1) | Diffs aus einer Diff-Datei extrahieren oder entfernen
`patchutils` | V:12, I:96 | 269 | fixcvsdiff(1) | von CVS erstellte Diff-Dateien, die patch(1) falsch interpretiert, reparieren
`patchutils` | V:12, I:96 | 269 | flipdiff(1) | die Reihenfolge zweier Patches ändern
`patchutils` | V:12, I:96 | 269 | grepdiff(1) | anzeigen, welche Dateien von einem Patch entsprechend einem regulären Ausdruck modifiziert werden
`patchutils` | V:12, I:96 | 269 | interdiff(1) | Unterschiede zwischen zwei Unified-Diff-Dateien anzeigen
`patchutils` | V:12, I:96 | 269 | lsdiff(1) | zeigen, welche Dateien von einem Patch verändert werden
`patchutils` | V:12, I:96 | 269 | recountdiff(1) | Zähler und Offsets in vereinheitlichten Context-Diffs neu berechnen
`patchutils` | V:12, I:96 | 269 | rediff(1) | Offsets und Zähler eines hand-editierten Diffs bereinigen
`patchutils` | V:12, I:96 | 269 | splitdiff(1) | inkrementelle Patches aussortieren
`patchutils` | V:12, I:96 | 269 | unwrapdiff(1) | Patches von fehlerhaften Zeilenumbrüchen befreien
`dirdiff` | V:0.1, I:1.4 | 167 | dirdiff(1) | Unterschiede zwischen Verzeichnissen anzeigen und zusammenführen
`docdiff` | V:0.02, I:0.19 | 554 | docdiff(1) | zwei Dateien Wort-für-Wort / Buchstabe-für-Buchstabe vergleichen
`makepatch` | V:0.01, I:0.16 | 99 | makepatch(1) | erweiterte Patch-Dateien erzeugen
`makepatch` | V:0.01, I:0.16 | 99 | applypatch(1) | erweiterte Patch-Dateien anwenden

### 10.4.1. Unterschiede für Quelldateien extrahieren

Die folgenden Prozeduren extrahieren die Unterschiede zwischen zwei Quelldateien und erzeugen vereinheitlichte Diff-Dateien "`file.patch0`" bzw. "`file.patch1`", abhängig vom Speicherort der Dateien:

    $ diff -u file.old file.new > file.patch0
    $ diff -u old/file new/file > file.patch1

### 10.4.2. Aktualisierungen für Quelldateien zusammenführen

Die Diff-Datei (alternativ auch Patch-Datei genannt) wird genutzt, um eine Programmaktualisierung zu senden. Die Seite, die die Änderungen empfängt, wendet die Aktualisierung wie folgt an:

    $ patch -p0 file < file.patch0
    $ patch -p1 file < file.patch1

### 10.4.3. Interaktives Zusammenführen (merge)

Wenn Sie zwei Varianten eines Quelltextes haben, können Sie mittels imediff(1) eine interaktive Zweiwege-Zusammenführung durchführen:

    $ imediff -o file.merged file.old file.new

Haben Sie drei Varianten eines Quelltextes, ist mit imediff(1) auch eine interaktive Dreiwege-Zusammenführung möglich:

    $ imediff -o file.merged file.yours file.base file.theirs

## 10.5. Git

Git ist derzeit das Werkzeug der Wahl für Versionskontrollsysteme (VCS), da es alles Nötige sowohl für lokales wie auch für fernes Code-Management erledigen kann.

Debian stellt freie Git-Dienste über Debian Salsa bereit. Dokumentation finden Sie unter https://wiki.debian.org/Salsa.

Hier einige Git-betreffende Pakete:

Tabelle 10.11. Liste von zu Git gehörigen Paketen und Befehlen

Paket | Popcon | Größe | Befehl | Beschreibung
--- | --- | --- | --- | ---
`git` | V:409, I:623 | 52512 | git(7) | Git, das schnelle, skalierbare, verteilte Versionskontrollsystem
`gitk` | V:4, I:26 | 2045 | gitk(1) | grafische Browser-Oberfläche mit Historie für Git-Depots
`qgit` | V:0.2, I:2.0 | 1431 | qgit(1) | grafische Browser-Oberfläche mit Historie für Git-Depots
`git-cola` | V:0.6, I:3.4 | 5129 | git-cola(1) | grafische Browser-Oberfläche mit Historie für Git-Depots
`tig` | V:2, I:11 | 1245 | tig(1) | console Git repository browser with history
`lazygit` | V:0.9, I:4.0 | 24167 | lazygit(1) | console Git repository browser with history
`git-gui` | V:2, I:16 | 2549 | git-gui(1) | grafische Oberfläche (ohne Historie) für Git
`git-email` | V:0.4, I:9.9 | 1229 | git-send-email(1) | eine Patch-Sammlung aus Git als E-Mail versenden
`git-buildpackage` | V:1.2, I:7.2 | 2027 | git-buildpackage(1) | das Debian-Paketieren mit Git automatisieren
`dgit` | V:0.1, I:1.0 | 755 | dgit(1) | Git-Interoperabilität mit dem Debian-Archiv
`imediff` | V:0.02, I:0.28 | 329 | git-ime(1) | Interaktives Werkzeug, das hilft, umfangreiche Git-Commits weiter aufzusplitten
`stgit` | V:0.07, I:0.49 | 6177 | stg(1) | Aufsatz für Git (Python)
`git-doc` | I:11 | 15192 | Nicht verfügbar | offizielle Dokumentation für Git
`gitmagic` | I:0.56 | 721 | Nicht verfügbar | "Git Magic", eine einfacher verständliche Anleitung für Git

### 10.5.1. Konfiguration eines Git-Clients

Sie möchten vielleicht wie folgt verschiedene globale Konfigurationsoptionen in "`~/.gitconfig`" zur Verwendung durch Git setzen, z.B. Name und E-Mail-Adresse:

    $ git config --global user.name "Name Surname"
    $ git config --global user.email yourname@example.com

Sie können das Standardverhalten von Git wie folgt auch noch weiter anpassen:

    $ git config --global init.defaultBranch main
    $ git config --global pull.rebase true
    $ git config --global push.default current

Wenn Sie an CVS- oder Subversion-Befehle gewohnt sind, können Sie wie hier auch folgende Befehls-Alias setzen:

    $ git config --global alias.ci "commit -a"
    $ git config --global alias.co checkout

Sie können mit folgendem Befehl Ihre globale git-Konfiguration kontrollieren:

    $ git config --global --list

### 10.5.2. Grundlegende Git-Befehle

An Vorgängen mit Git sind verschiedene Datenbereiche beteiligt:

- Der Arbeitsbereich, der für den Benutzer sichtbare Dateien enthält und dort Änderungen erlaubt.

  - Änderungen müssen explizit ausgewählt und dem Index hingefügt werden, um aufgezeichnet zu werden. Dies erledigen die Befehle `git add` und `git rm`.

- Der Index, der hinzugefügte Dateien enthält.

  - Dem Index hinzugefügte Dateien werden auf Anfrage in das lokale Depot übernommen. Dies erledigt der Befehl `git commit`.

- Das lokale Depot, das übernommene Dateien enthält.

  - Git zeichnet die Historie der übernommenen Daten auf und bereitet diese in Form von Zweigen (Branches) im Depot auf.

  - Das lokale Depot kann über den `git push`-Befehl Daten an das ferne Depot senden.

  - Das lokale Depot kann über die Befehle `git fetch` und `git pull` Daten vom fernen Depot empfangen.

    - Der Befehl `git pull` führt `git merge` oder `git rebase` nach dem `git fetch`-Befehl aus.

    - Dabei führt `git merge` zwei separate Zweige (Branches) zu einem Stand zusammen. (Dies ist das Standardverhalten von `git pull` - solange es nicht bewusst angepasst wurde - und sollte passend sein für Upstream-Entwickler, die Zweige (Branches) an viele Leute verteilen.)

    - Dabei erstellt `git rebase` einen einzigen Zweig (Branch) aus der aufeinander folgenden Historie des fernen Zweigs, dem der lokale Zweig folgt. (Dies entspricht der Anpassung `pull.rebase true`, und ist vermutlich passend für den Rest von uns.)

- Das ferne Depot, das übernommene Dateien enthält.

  - Für die Kommunikation zum fernen Depot wird ein sicheres Protokoll wie SSH oder HTTPS verwendet.

Als Arbeitsbereich gilt der Bereich außerhalb des `.git/`-Verzeichnisses. Zu den Dateien innerhalb von `.git/` gehören der Index, die lokalen Depotdaten und einige Textdateien für die Git-Konfiguration.

Hier ein Überblick über die wichtigsten Git-Befehle:

Tabelle 10.12. Wichtige Git-Befehle

Git-Befehl | Funktion
--- | ---
`git init` | ein (lokales) Depot erstellen
`git clone URL` | duplizieren des fernen Depots in ein lokales Depot mit einem Arbeitsverzeichnis
`git pull origin main` | aktualisieren des lokalen `main`-Zweigs von dem fernen Depot `origin`
`git add .` | Änderungen in Dateien des Arbeitsbereichs zum Index hinzufügen - aber nur für Dateien, die bereits im Index existieren
`git add -A .` | Änderungen in Dateien des Arbeitsbereichs zum Index hinzufügen - für alle Dateien; betrifft auch Entfernungen von Dateien
`git rm dateiname` | Datei(en) aus dem Arbeitsbereich und dem Index entfernen
`git commit` | dem Index hinzugefügte Änderungen in das lokale Depot übernehmen (Commit)
`git commit -a` | alle Änderungen im Arbeitsbereich zum Index hinzufügen und in das lokale Depot übernehmen (vereint `git add` und `git commit`)
`git push -u origin zweig_name` | das ferne Depot `origin` vom lokalen Depot namens `zweig_name` aktualisieren (erstmaliger Aufruf)
`git push origin zweig_name` | das ferne Depot `origin` vom lokalen Depot namens `zweig_name` aktualisieren (nachfolgende Aufrufe)
`git diff baum1 baum2` | Unterschiede anzeigen zwischen Commit baum1 und Commit baum2
`gitk` | grafische GUI-Anzeige der Historie eines Zweigs (Branch) von einem VCS-Depot

### 10.5.3. Git-Tipps

Hier einige Tipps zu Git:

Tabelle 10.13. Git-Tipps

Git-Befehlszeile | Funktion
--- | ---
`gitk --all` | vollständige Git-Historie anzeigen und weiterverarbeiten, wie z.B. Zurücksetzen des HEAD auf einen anderen Commit, Herauspicken von einzelnen Änderungen, Erzeugen von Tags und Branches, ...
`git stash` | einen sauberen Arbeitsbereich erhalten, ohne Daten zu verlieren
`git remote -v` | Einstellung für ferne Depots anzeigen
`git branch -vv` | Einstellung für Zweig (Branch) anzeigen
`git status` | Status des Arbeitsbereichs anzeigen
`git config -l` | Git-Einstellungen auflisten
`git reset --hard HEAD; git clean -x -d -f` | alle Änderungen im Arbeitsbereich zurücksetzen und vollständig bereinigen
`git rm --cached dateiname` | bereits über `git add dateiname` zum Index hinzugefügte Änderungen zurücknehmen
`git reflog` | Git-Referenz-Log anzeigen (nützlich, um Commits von gelöschten Zweigen (Branches) wiederherzustellen)
`git branch neuer_zweig_name HEAD@{6}` | einen neuen Zweig aus reflog-Informationen erzeugen
`git remote add new_remote URL` | ein fernes Depot `new_remote` mit angegebener URL hinzufügen
`git remote rename origin upstream` | den Namen des fernen Depots `origin` in `upstream` umbenennen
`git branch -u upstream/branch_name` | das Remote-Tracking auf das ferne Depot `upstream` und seinen Zweig namens `branch_name` setzen.
`git remote set-url origin https://foo/bar.git` | URL von `origin` ändern
`git remote set-url --push upstream DISABLED` | push zu `upstream` deaktivieren (passen Sie `.git/config` an, um dies wieder zu aktivieren)
`git remote update upstream` | Updates aller fernen Zweige im `upstream`-Depot abrufen
`git fetch upstream foo:upstream-foo` | einen lokalen (eventuell verwaisten) Zweig `upstream-foo` als Kopie des `foo`-Zweigs im `upstream`-Depot erzeugen
`git checkout -b topic_branch ; git push -u topic_branch origin` | einen neuen Zweig namens `topic_branch` erzeugen und nach `origin` aktualisieren (push)
`git branch -m alter-name neuer-name` | den Namen eines lokalen Zweigs umbenennen
`git push -d origin zu-loeschender-zweig` | einen fernen Zweig (Branch) löschen (neue Methode)
`git push origin :zu-loeschender-zweig` | einen fernen Zweig (Branch) löschen (alte Methode)
`git checkout --orphan unconnected` | einen neuen `unconnected`-Zweig erzeugen
`git rebase -i origin/main` | Neuordnen/Löschen/Verdichten der Commits von `origin/main`, um eine saubere Branch-Historie zu bekommen
`git reset HEAD^; git commit --amend` | Verdichten der letzten 2 Commits in einen einzigen
`git checkout topic_branch ; git merge --squash topic_branch` | Verdichten eines kompletten Zweigs `topic_branch` in einen Commit
`git fetch --unshallow --update-head-ok origin '+refs/heads/*:refs/heads/*'` | einen shallow-Clone in einen Clone aller Zweige konvertieren
`git ime` | den letzten Commit in eine Serie von kleineren Datei-für-Datei-Commits konvertieren (`imediff`-Paket wird benötigt)
`git repack -a -d; git prune` | Neupacken des lokalen Depots in ein einzelnes Pack (dies könnte dazu führen, dass die Wiederherstellung verlorener Daten aus gelöschten Zweigen nicht mehr möglich ist, usw.)

| Warnung
Nutzen Sie in der Tag-Zeichenkette keine Leerzeichen, auch wenn Werkzeuge wie gitk(1) dies ermöglichen. Andere `git`-Befehle könnten dadurch ins Stocken geraten.

| Achtung
Wenn für einen lokalen Zweig, der bereits über push in das ferne Depot übergeben wurde, ein rebase oder squash durchgeführt wird, könnte ein erneuter push gewisse Risiken beinhalten und die Option `--force` erfordern. Dies ist für den `main`-Zweig ein normalerweise unerwünschter Vorgang, könnte aber für einen topic-Zweig akzeptabel sein, bevor dieser in den `main`-Zweig integriert wird.

| Achtung
Der direkte Aufruf eines `git`-Unterbefehls mittels "`git-xyz`" über die Befehlszeile ist seit dem Frühjahr 2006 veraltet.

| Tipp
Wenn eine ausführbare Datei namens `git-foo` in dem durch `$PATH` definierten Pfad existiert, wird dieser `git-foo`-Befehl ausgeführt, indem man "`git foo`" (ohne Bindestrich!) auf der Befehlszeile aufruft. Dies ist eine Funktionalität des `git`-Befehls.

### 10.5.4. Weitere Referenzen zu Git

Hier finden Sie weitere Informationen:

- Handbuchseite: git(1) (`/usr/share/doc/git-doc/git.html`)

- git-Benutzerhandbuch (engl.) (`/usr/share/doc/git-doc/user-manual.html`)

- gittutorial: Einführung in git (engl.) (`/usr/share/doc/git-doc/gittutorial.html`)

- gittutorial-2: Einführung in git - Teil 2 (engl.) (`/usr/share/doc/git-doc/gittutorial-2.html`)

- Anleitung für die alltägliche git-Nutzung mit ungefähr 20 Befehlen (engl.) (`/usr/share/doc/git-doc/giteveryday.html`)

- Git Magic (`/usr/share/doc/gitmagic/html/index.html`)

### 10.5.5. Andere Versionskontrollsysteme

Versionskontrollsysteme (VCS) sind auch teilweise bekannt als Revision Control System (RCS) oder Software Configuration Management (SCM).

Hier eine Zusammenfassung von VCS-Systemen im Debian-System abseits von Git:

Tabelle 10.14. Liste anderer Versionskontrollsystem-Werkzeuge

Paket | Popcon | Größe | Werkzeug | VCS-Typ | Erläuterung
--- | --- | --- | --- | --- | ---
`mercurial` | V:4, I:23 | 2575 | Mercurial | verteilt | DVCS in Python und ein bisschen C
`darcs` | V:0.2, I:3.3 | 38856 | Darcs | verteilt | DVCS mit schlauer Algebra von Patches (langsam)
`tla` | V:0.04, I:0.70 | 1022 | GNU arch | verteilt | DVCS hauptsächlich von Tom Lord (historisch)
`bzr` | V:0.1, I:4.3 | 28 | GNU Bazaar | verteilt | von `tla` beeinflußtes DVCS, geschrieben in Python (historisch)
`subversion` | V:9, I:55 | 4848 | Subversion | fern | "CVS done right" (CVS richtig gemacht), neuerer Standard für fernes VCS (historisch)
`cvs` | V:3, I:23 | 4835 | CVS | fern | früherer Standard für fernes VCS (historisch)
`tkcvs` | V:0.12, I:0.91 | 34 | CVS, … | fern | GUI-Oberfläche von VCS-Depots (CVS, Subversion, RCS)
`rcs` | V:2.1, I:9.5 | 578 | RCS | lokal | "Unix SCCS done right" (Unix SCCS richtig gemacht; historisch)
`cssc` | V:0.01, I:0.30 | 2044 | CSSC | lokal | Klon von Unix SCCS (historisch)

[4] Medien zu verwenden, die nur einmal beschrieben werden können (wie CD-R/DVD-R), schützt vor versehentlichem Überschreiben. (In Abschnitt 9.8, „Binärdaten“ lesen Sie, wie Sie von der Befehlszeile aus auf die Speichermedien schreiben können. Die grafische Oberfläche der GNOME-Arbeitsplatzumgebung bietet Ihnen auch einen einfachen Weg über das Menü: "Orte→CD/DVD-Ersteller".)

[5] Einige dieser Daten kann nicht wieder hergestellt werden, selbst wenn die exakt gleichen Eingaben erneut getätigt werden.

[6] Falls Sie "`~/.vimrc`" statt "`~/.vim/vimrc`" verwenden, passen Sie diese bitte entsprechend an.

Kapitel 9. Systemtipps |  | Kapitel 11. Datenkonvertierung