Wohin mit GnuPG-Schlüsseln?

RRZK-Kompass Nr. 101 - 1. Juni 2004

Wohin mit GnuPG-Schlüsseln?

Sichere Aufbewahrung von Daten unter Linux

Im den Ausgaben 94 und 95 des RRZK-Kompass (s. http://www.uni-koeln.de/rrzk/kompass/) wurde der Einsatz von GnuPG zur Verschlüsselung elektronischer Post beschrieben. Die dort angesprochenen Verfahren gelten nach heutigen Kenntnissen für die nächsten Jahre als sicher, jedoch nur so lange, wie die privaten Schlüssel sicher aufbewahrt werden.

GnuPG legt bei der Generierung eines neuen Schlüsselpaares ein Verzeichnis .gnupg im Home-Verzeichnis des Benutzers an. In diesem befinden sich dann zwei sogenannte Schlüsselringe oder Schlüsselbunde, die privater und öffentlicher Schlüsselring genannt werden. Private Schlüssel sind durch eine Passphrase geschützt, die auch als Mantra oder Geheimschlüssel bezeichnet wird. Normalerweise reicht das aus. Was jedoch, wenn ein Angreifer root-Zugang zu dem Linux-Rechner erhält, auf dem Sie Ihre Schlüssel aufbewahren? Zwar wird er nicht ohne weiteres an das von Ihnen gewählte Mantra kommen, mit dem die privaten Schlüssel geschützt sind, er kann die Schlüssel jedoch von der Festplatte löschen. Damit sind für Sie die Schlüssel verloren. Ein Grund also, die Schlüssel auf einem externen Speichermedium zu sichern.

Gelingt es dem Angreifer, durch Ausprobieren an Ihr Mantra zu kommen, kann er in Ihrem Namen Nachrichten verfassen und Ihnen auf diese Weise Schaden zufügen. Es ist also sinnvoll, die Schlüssel gar nicht erst auf der Festplatte zu haben, sondern auf einer Diskette, CD-RW, DVD oder einem USB-Stick, um nur einige Möglichkeiten zu nennen. Selbstverständlich muss dieser Datenträger dann sicher aufbewahrt werden.

Wir beschreiben hier eine Methode, Daten aller Art auf einem USB-Stick aufzubewahren, und zwar in einem stark verschlüsselten Daten-Container. Der Aufwand hält sich in Grenzen, und wenn Sie das Dateisystem einmal angelegt haben, kann der Zugriff auf das Medium weitgehend automatisiert werden.

Das verwendete Linux-System ist ein RedHat9-Rechner mit aktuellen Kernelpaketen, ein Rekompilieren des Kernels ist nicht notwendig. Allerdings müssen neue Versionen der Befehle mount und losetup installiert werden.

Die Schritte im Einzelnen:

Erstellen der Programme mount und losetup mit Crypto-Unterstützung

Laden benötigter Kernelmodule

Einrichtung eines Gerätes unter Verwendung des Loopback-Device

Einrichtung eines Datenblocks in dem Gerät

Mounten des Datenblocks, Herstellung eines Dateisystems darin

Schreiben der Daten (Schlüsselringe, Zeugnisse etc.)

Das Konzept

Normalerweise schreibt man Daten in ein Dateisystem, das sich auf einem Blockdevice (auch blockorientiertes Gerät genannt) befindet. Wer Linux im Einsatz hat, kennt vielleicht die Bezeichnung /dev/hda1 für ein solches Gerät. In diesem Beispiel handelt es sich um die erste Partition (1) auf dem Gerät /dev/hda, einer IDE-Festplatte am ersten Bus. Dieses Gerät bietet die Möglichkeit, verschiedene Dateisysteme zu verwenden. Unter Linux kommen sehr oft ext2 und ext3 zum Einsatz. Einem Dateisystem obliegt die Verwaltung der Dateien und Verzeichnisse, das Blockdevice dient schlicht als Gerät, um Bits zu speichern, das Dateisystem gibt den Daten die Struktur. Wie genau das Blockdevice angesprochen und verwaltet wird, spielt eigentlich keine Rolle und ist für den Benutzer transparent. Das Ansprechen des eigentlichen physikalischen Gerätes (also Festplatte, CD-Rom-Gerät etc.) liegt im Aufgabenbereich des Treibers.

Unter Linux ist es möglich, zwischen Blockdevice und Dateisystem eine Zwischenschicht einzuschieben. Was das Dateisystem auf das Blockdevice schreiben möchte, kann einfach durch die Zwischenschicht durchgeleitet, aber auch von ihr verändert werden. Verschlüssselung ist eine solche Veränderung, die die Zwischenschicht, das Loopback-Device, durchführen kann. Statt eines Blockdevices kann aber auch eine Datei in einem Dateisystem zum Schreiben und Lesen genutzt werden.

Damit das Loopback-Device ver- und entschlüsseln kann, muss es in einer speziellen Version mit Kryptographieunterstützung vorliegen, die man als kryptographisches Loopback-Device oder kurz Cryptoloop bezeichnet (Abbildung).

Prinzip der Verschlüsselung

Der Anwender erzeugt dann auf einem Datenträger eine Datei beliebiger Länge, z.B. 10 Megabytes groß. Diese Datei werden wir als Container für verschlüsselte Daten konfigurieren. In dem Container kann ein Dateisystem angelegt werden. Dazu richtet man ein Cryptoloop-Device so ein, dass es diese Datei als blockorientiertes Gerät verwendet (mit dem Befehl losetup). Danach bindet man dieses Konstrukt mit dem Befehl mount in den Dateibaum ein.

Wer den Datenträger dann ohne Kenntnis eines entsprechend langen Passwortes in die Hand bekommt, hat nur eine 10 MB große Datei mit unlesbarem Inhalt vor sich.

Schritt für Schritt-Anleitung unter RedHat

Vorbemerkung: Ein Befehl in der Kommandozeile wird zusammen mit dem Prompt der bash (einem "größer als" (>)) abgedruckt. Diesen gibt man nicht mit ein. Der Prompt dient hier dem Zweck, Befehle und Eingaben von der Ausgabe eines Programmes unterscheidbar zu machen.

Der Kernel eines aktuellen RedHat-Systems bringt die Werkzeuge mit, die für den Umgang mit einem Cryptoloop-Device notwendig sind. Dies sind die Kernelmodule cryptoapi, cryptoloop und cipher-aes.

Installation der Befehle mount und losetup mit Kryptographie-Unterstützung

Von der Internetseite

http://www.kernel.org/pub/linux/utils/util-linux

lädt man sich das Quellpaket util-linux-2.11r.tar.gz herunter (als Benutzer root). Es gibt neuere Versionen von util-linux, wir verwenden jedoch 2.11r, da die benötigten Patches für diese Version vorliegen. Die Patchdatei erhält man hier:

http://prdownloads.sourceforge.net/cryptoapi/util-linux-2.11r.patch.gz

Das Quellpaket wird dann entpackt

> tar xfz util-linux-2.11r.tar.gz

Ebenso der Patch:

> gunzip util-linux-2.11r.patch.gz

Nach dem Wechsel in das neu erzeugte Verzeichnis util-linux-2.11r patcht man die Quellen mit:

> patch -p1 > ../util-linux-2.11r.patch

Wenn der Patch richtig abläuft, erhält man die folgende Ausgabe:

patching file mount/Makefile patching file mount/lomount.c patching file mount/lomount.h patching file mount/losetup.8 patching file mount/mount.8 patching file mount/mount.c patching file mount/rmd160.c patching file mount/rmd160.h patching file mount/sha512.c patching file mount/sha512.h patching file mount/sundries.c
Nun können die Programme mount, umount und losetup mit Crypto-Unterstützung erzeugt werden. Geben Sie dazu in der Kommandozeile ein:

> ./configure

und

> make

Hinweis: Nicht zusätzlich "make install" eingeben!

Man wechselt ins Unterverzeichnis mount (mit cd mount), darin befinden sich die Programme mount, umount und losetup. Diese drei Dateien kopiert man nun unter leicht verändertem Namen in das Verzeichnis /usr/local/bin und schaltet sie auf suid-root (sie laufen dann mit root-Rechten, dies ist für den gesperrten Speicherzugriff notwendig):

> cp mount /usr/local/bin/mount.cr > cp umount /usr/local/bin/umount.cr > cp losetup /usr/local/bin/losetup.cr > cd /usr/local/bin > chmod u+s mount.cr umount.cr losetup.cr

Der Vorteil dieses Vorgehens ist, dass die Originaldateien erhalten bleiben.

Laden der benötigten Kernelmodule

Als Benutzer rootgibt man an der Kommandozeile ein:

> modprobe cryptoapi > modprobe cryptoloop > modprobe cipher-aes

Mit lsmod sieht man die installierten Module (gekürzte Ausgabe):

cipher-aes 22432 0 cryptoloop 2764 0 loop 10640 3 [cryptoloop] cryptoapi 6436 5 [cipher-aes cryptoloop]

Erzeugen eines Containers

In diesem Beispiel verwenden wir einen USB-Speicherstick. Dieser ist mit einem VFAT-Filesystem vorformatiert, er wurde direkt aus der Packung genommen und in einen USB-Port gesteckt. Zunächst muss das Device eingebunden werden. Dazu benötigt man einen Mountpoint, den wir im Verzeichnis /mnt als root anlegen:

> mkdir /mnt/stick > mkdir /mnt/secure

Ein solches Verzeichnis kann ein Benutzer sich auch in seinem eigenen Home-Verzeichnis selbst anlegen, es ist dort weniger Benutzern zugänglich. Dabei sollte nicht vergessen werden, die Rechte für andere Nutzer einzuschränken (z.B. mit chmod 700 /home/nutzer/secure).

Der erste Mountpoint dient zum Einhängen des USB-Stick-Dateisystems, der zweite Mountpoint nimmt später den verschlüsselten Container auf.

Um zu erfahren, um welches Device es sich handelt, ruft man fdisk auf:

> /sbin/fdisk -l

Ausgabe (gekürzt):
Device       Boot Start   End     Blocks    Id      System 
/dev/sdb1            1    801     205040     b    Win95 FAT32
In diesem Fall entspricht der USB-Stick dem Device /dev/sdb1. Die folgende Zeile kann in die Datei /etc/fstab eingetragen werden, damit die Benutzer den Befehl mount auf dieses Device anwenden können:

/dev/sdb1 /mnt/stick auto noauto,user,exec 0 0

Als normaler Benutzer kann man nun das Device mounten:

> mount /mnt/stick

Anlegen des Containers mit Dateisystem

Der Container der Länge von z.B. 10 Megabytes wird angelegt (alles in einer Zeile):

> dd if=/dev/urandom of=/mnt/stick/container bs=1024k count=10

Als Quelle (if, input file) dient ein Zufallszahlengenerator. Nach Anlegen des Containers beinhaltet dieser 10 Megabytes Zufallszahlen. Nun kommt das Cryptoloop-Device zum Einsatz, als Verschlüsselungsverfahren wird AES mit 256 Bit Schlüssellänge benutzt. Zum Schutz des Schlüssels muss noch eine Passphrase angegeben werden, sie sollte nicht zu kurz sein, 20 Byte sind ein guter Wert. Die Passphrase wird nur einmal abgefragt (alles in einer Zeile):

> /usr/local/bin/losetup.cr -e aes /dev/loop0 /mnt/stick/container

available keysizes (bits): 128 192 256 Keysize:

Hier 256 eingeben:

Keysize: 256 Password:

Eine lange Passphrase kann sein: "D3sidd8 HG23lls$222" oder ähnliches, oft hilft es, sich einen Satz zu denken und z.B. die Anfangs- und Endbuchstaben der einzelnen Worte sowie die Interpunktion als Passphrase zu benutzen.

Das Loopback-Device ist nun ein blockorientiertes Gerät, in dem man ein ext2-Dateisystem erzeugen kann. Dies muss man nur einmal machen.

> mke2fs /dev/loop0

Die Ausgabe lautet z.B.:

Filesystem label= OS type: Linux Block size=1024 (log=0) Fragment size=1024 (log=0) 2560 inodes, 10240 blocks 512 blocks (5.00%) reserved for the super user First data block=1 2 block groups 8192 blocks per group, 8192 fragments per group 1280 inodes per group Superblock backups stored on blocks: 8193
Writing inode tables: done Writing superblocks and filesystem accounting information: done

Die Datei /mnt/stick/container ist nun 10 MB groß, mit dem Cryptoloop-Device /dev/loop0 verbunden und als Blockorientiertes Gerät mit einem ext2-Dateisystem formatiert. Dieses kann nun mit mount.cr ins lokale Dateisystem integriert werden:

> /usr/local/bin/mount.cr /dev/loop0 /mnt/secure

Um den Container sicher aus dem Dateisystem zu entfernen, geht man wie folgt vor:

> /usr/local/bin/umount.cr /mnt/secure > /usr/local/bin/losetup.cr -d /dev/loop0

Automatisierung des Mountvorgangs

Die Mount-Prozedur lässt sich stark vereinfachen. Damit ein Benutzer des Rechners ein verschlüsseltes Dateisystem einrichten kann, trägt man die folgende Zeile in die Datei etc/fstab ein (alles in einer Zeile, user ersetzen durch den entsprechenden Benutzernamen!):

/mnt/stick/container /home/user/crypto ext2 defaults,noauto,user,loop,encryption=aes 0 0

Der eingetragene Benutzer legt nun ein Verzeichnis /home/user/crypto an (mit mkdir ~/crypto) und kann das Device /dev/sdb1 auf /mnt/stick einbinden, und danach den verschlüsselten Container in /home/user/crypto mounten:

> /usr/local/bin/mount.cr /mnt/stick/ > /usr/local/bin/mount.cr crypto/
Available keysize (bits): 128 192 256 Keysize: 256 Password:

Nach Eingabe der Passphrase befindet sich der Inhalt des Containers im Verzeichnis /home/user/crypto. Schreibt, erzeugt oder ändert man Dateien in diesem Verzeichnis, werden diese Daten als verschlüsselte Informationen in dem Container abgelegt.

Wenn der Container nicht mehr benötigt wird, muss er unbedingt mit umount oder /usr/local/bin/umount.cr aus dem lokalen Dateisystem entfernt werden:

> /usr/local/bin/umount.cr ~/crypto > /usr/local/bin/umount.cr /mnt/stick

Dann erst darf der USB-Stick vom Rechner abgezogen werden, sonst droht Verlust von Daten.

Sichere Aufbewahrung der GnuPG-Schlüssel

Wenn die Schritte in der oben genannten Anleitung nachvollzogen worden sind, kann man als normaler Benutzer eines Linuxrechners Daten sicher auf einem USB-Stick ablegen, dies bietet sich besonders für die Schlüssel einer GnuPG-Installation an. Am einfachsten ist es, das Verzeichnis ".gnupg" (nach zusätzlicher Erzeugung einer Sicherheitskopie z.B. auf CD-Rom!) in den Container zu verschieben und einen symbolischen Link so anzulegen, dass jeder Zugriff auf das Verzeichnis /home/user/.gnupg auf das Verzeichnis /home/user/crypto/.gnupg umgeleitet wird.

Schritt für Schritt, als normaler Benutzer im eigenen Home-Verzeichnis (/home/user als Beispiel) geht das wie folgt:

Sicherung des Verzeichnisses .gnupg auf einem zusätzlichen Medium, z.B. CD-Rom. Solange noch experimentiert wird, kann man auch eine lokale Kopie erzeugen. Datenverlust ist durchaus möglich, daher immer eine Sicherung vornehmen!

Mounten des USB-Sticks (z.B. als /mnt/stick) und des verschlüsselten Containers (im Verzeichnis /home/user/crypto). Siehe dazu den Abschnitt "Automatisierung des Mount-Vorgangs". Beachten Sie eventuelle Fehlermeldungen und stellen Sie mit dem Befehl df sicher, dass der Container wirklich gemounted ist.

Verschieben des Verzeichnisses .gnupg in den Container:
> mv ~/.gnupg ~/crypto/

Anlegen des symbolischen Links:
> ln -s ~/crypto/.gnupg ~/.gnupg

GnuPG findet dann alle benötigten Daten.

Bevor der USB-Stick abgezogen werden kann, müssen die Dateisysteme wieder entfernt werden:

> umount ~/crypto > umount /mnt/stick

Lars Packschies