GnuPG HowTo

Dieser Artikel soll eine kurze bebilderte Anleitung zu GPG darstellen. Er entstand im Rahmen eines Vortrags zur Kryptographie im Allgemeinen und GPG im Besonderen, daher gehe ich hier davon aus, daß die Prinzipien der Kryptographie dem Lesenden vertraut sind.

Schüsselpaar erstellen, bearbeiten, verteilen, widerrufen

Erzeugung eines Schlüsselpaares:

$ gpg --gen-key aufrufen

Im Allgemeinen bietet es sich an einen DSA / El Gamal Schlüssel zu erzeugen, da einfache DSA oder RSA Schlüssel nur zum Signieren verwendet werden können.

die Größe für einen DSA / El Gamal Schlüssel sollte z. Zt. bei 1024 Bit liegen, RSA Schlüssel erfordern z. Zt. wenigstens 2048 Bit

Man kann ein Verfallsdatum für einen Schlüssel vergeben, nach Ablauf des Datums wird der Schlüssel ungültig, man kann ihn nicht mehr zum verschlüsseln verwenden. Entschlüsseln und Signaturverifikation sind mit abgelaufenen oder zurückgerufenen Schlüsseln noch möglich. Ob man ein Verfallsdatum angibt, liegt im Ermessen des Benutzers.

Nachdem die Parameter des Schlüssels übergeben wurden, müssen nun die Benutzerdaten eingegeben werden. Hierbei sind der korrekte Vor- und Nachname sowie die eMailadresse und wahlweise ein Kommentar (z. B. eine Webseite oder ein Hinweis auf Firmenzugehörigkeit) anzugeben. Die wenigsten Benutzer akzeptieren übrigens Schlüssel mit Pseudonymen statt Realnamen. Anschließend wird eine Passphrase verlangt, die zweimal eingegeben werden muss. Diese Passphrase sollte sorgfältig gewählt werden, da mit ihr der Zugriff auf den privaten Schlüssel möglich ist.

Abschließend wird der Schlüssel mit den entsprechenden Eigenschaften generiert und dem Keyring hinzugefügt. Je nach Systemleistung und gewählter Schlüsselgröße dauert die Generierung entsprechende Zeit. Da GnuPG hierbei große und vor allem echte Zufallsdaten erzeugen muss, kann es vorkommen das eine Warnmeldung ausgegeben wird, die dazu auffordert das System zu benutzen um weitere Randomseed zu generieren. Hierbei reicht es meist einfach ein größeres Programm wie GIMP oder LaTeX anzuwerfen oder profanerweise "find /" laufen zu lassen.

Der Inhalt des Keyrings lässt sich mit gpg --list-keys abrufen. gpg zeigt hier die Daten des erzeugten Schlüssels an.

Hierbei bedeutet:

pub  1024D/F610A67A 2004-04-21 Max Mustermann (Testschluessel!) <max@mustermann.local>;
 	sub  1024g/37E3FBE1 2004-04-21

pub = öffentlicher Schlüssel
 	1024D = 1024 bittiger DSA Schlüssel
 	F610A67A = hexadezimale Schlüssel-ID
 	2004-04-21 = Datum der Erstellung des Schlüssels
 	sub = Unterschlüssel (Subkey)
 	1024g = 1024 bittiger El Gamal Schlüssel
37E3FBE1 = hexadezimale Subschlüssel-ID

Schlüssel extrahieren

gpg ist selbstverständlich auch in der Lage einen Schlüssel aus dem Ring in eine Datei zu exportieren. Dies geschieht mit: $ gpg -a --export 0xF610A67A > key Die Option --export erwartet die Schlüssel-ID des zu exportierenden Schlüssels, die Option -a schaltet das sogenannte ASCII-Armoring an. Da der Schlüssel Zufallsdaten repräsentiert, kommen in ihm auch nichtdruckbare Zeichen (bspw. CR/LF oder Alarm) vor, übergibt man -a werden diese Zeichen durch druckbare ersetzt und die Handhabung des Schlüssels vereinfacht sich erheblich. Durch die Angabe der Umleitung wird der Schlüssel in die Datei ./key geschrieben, ohne Umleitung gibt gpg den Schlüssel auf stdout, was im Bild dargestellt wurde. Die so erzeugte Datei lässt sich bspw. auf einem httpd oder ftpd zum Download anbieten oder problemlos per eMail verschicken.

Möchte man die Kommunikation mit anderen, evtl unbekannten, Kommunikationspartnern erleichtern, sollte man den öffentlichen Schlüssel auf einen Keyserver einspielen. Dazu verwendet man ein angebotenese Webinterface wie bspw. <a href="http://pgp.mit.edu:11371/#submit">http://pgp.mit.edu:11371/#submit</a> oder aber direkt gpg. Dazu muss in der ~/.gnupg/options lediglich ein Keyserver angegeben werden (z.B. so: keyserver http://pgp.mit.edu:11371/), der verwendet werden soll. Möchte man nun Schlüssel ex-/importieren, geschieht dies einfach mit:

$ gpg --send-key 0xF610A67A
$ gpg --recv-key 0xb3fbae33

Damit man nicht jeden neuen Schlüssel von Hand importieren muss, kann man in ~/.gnupg/options die Option keyserver-options auto-key-retrieve setzen.

Bestehenden Schlüssel manipulieren

gpg bietet vielfältige Möglichkeiten einen bestehenden Schlüssel zu manipulieren. Dazu ruft man lediglich $ gpg --edit-key 0xF610A67A auf und gelangt so in die gpg-shell. Das Bild zeigt die Optionen die gpg bietet. Wir können bspw. eine ID ändern (Kommentar, eMail), löschen oder hinzufügen oder andere Schlüssel signieren. Eine neue ID können wir mit adduid hinzufügen, das Prozedere gleicht dem der Schlüsselerstellung (außer das kein neuer Schlüssel generiert wird). Löschen oder Ändern einer ID geschieht analog mit deluid bzw. revuid

Auf die Arbeit mit Signaturen werde ich später genauer eingehen.

Um einen Schlüssel zu widerrufen (also als nicht mehr benutzbar zu markieren) ist das Senden eines Revocation certificates an einen Keyserver erforderlich. Widerrufen sollte man einen Schlüssel, wenn dieser kompromittiert oder anderweitig unbrauchbar wurde. Es bietet sich an ein Revocation certificate sofort nach Erstellung des Schlüssels zu generieren und geeignet abzulegen, um bei Verlust des privaten Schlüssels einen nötigen Widerruf durchführen zu können. Hierzu ruft man gpg --gen-revoke auf, beantwortet zwei Fragen zum Grunde des Widerrufs und erhält das gewünschte Zertifikat, welches danach bspw. verschlüsselt auf Diskette oder als Ausdruck an geeigneter Stelle gesichert werden sollte.

Signaturen und Verschlüsselung

Eine kurze Begriffsklärung

verschlüsseln: Daten werden durch mathematische Verfahren "unlesbar" gemacht und können nur nach Angabe eines Schlüssels (z. B. Passwort) wieder lesbar dargestellt werden. Unbefugte können Daten nicht lesen oder verändern.
signieren: durch ein mathematisches Verfahren wird eine Signatur über Daten erstellt, dies dient dazu die Integrität der Daten zu sichern. Ändert also jemand die Daten, passt die Signatur nicht mehr und die Manipulation wird angezeigt. Zum Erstellen der Signatur ist der private Schlüssel erforderlich, dadurch lässt sich auch die Authenzität eines Absenders nachweisen.
symmetrisch: Daten werden mit genau einem Schlüssel ver- und entschlüsselt. Kommunikationspartner müssen also den Schlüssel (z. B. ein Passwort) austauschen.
asymmetrisch: Es werden Schlüsselpaare aus öffentlichem Sclüssel des Empfängers und privatem Schlüssel des Senders verwendet. Entschlüsseln kann die Daten nur, wer Zugriff auf den privaten Schlüssel des Empfängers hat.

Signaturen

Da PGP ursprünglich nur für eMails angedacht war, wurde eine sogenannte Inline-Signatur erstellt, d.h. die erzeugte Signatur wurde <i>in</i> die Datei geschrieben. Dies funktioniert bei einer eMail, die ja nichts weiter als simpler ASCII-Text ist soweit ganz gut, bei einer anders codierten Datei (PDF, MP3, JPEG …) funktioniert dies verständlicherweise nicht. Daher wurde ebenfalls eine detached (allein stehend, abgelöst) Signatur eingeführt. Hierbei wird die Signatur in eine extra Datei geschrieben.

Signaturen erzeugen

gpg kennt nun drei Optionen um Signaturen zu erzeugen, diese werde ich hier an einem Beispiel erklären. Zuerst erzeuge ich die Datei date.txt die einfach nur die aktuelle Uhrzeit enthält und signiert werden soll: date > date.txt nun erzeugen wir eine inline Signatur, (dazu werden wir nach der Passphrase gefragt): gpg -s date.txt

Dies führt zu der Datei date.txt.gpg, die die komprimierte Signatur enthält, welche nicht im ASCII-Armor vorliegt, daher verwenden wir besser: gpg -a -s date.txt was zu date.txt.asc führt, die diesmal die Signatur im ASCII-Armor enthält. Mit gpg --clearsign date.txt erzeugt man ebenfalls eine Signatur, aber nicht komprimiert. gpg -a -b date.txt erzeugt eine bereits erwähnte "detached signature" eignet sich also insbesondere für nicht-Text Dateien.

Signaturen verifizieren

Um eine Signatur zu prüfen, verwendet man die Option -v: gpg -v date.txt.asc gpg erwartet hierbei das die zu prüfende Datei date.txt heißt, weicht dies von Namen der Signaturdatei ab, ist der Dateiname als dritte Option zu übergeben.

Die Signatur ist in Ordung. Es werden Schlüssel sowie Zeitpunkt der Signatur angezeigt.

date.txt wurde verändert, die Signatur ist demzufolge ungültig (BAD) Eine Signatur, die in einer Extradatei (detached) untergebracht ist, wird über den gesamten Inhalt der signierten Datei erzeugt, eine alte Inline-Signatur gilt nur für die Teile einer Signatur, die von ihr eingegrenzt wurden. Ein Beispiel:

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

It's backup day today so I'm pissed off.  Being the BOFH, however, does have
it's advantages.  I reassign null to be the tape device - it's so much more
economical on my time as I don't have to keep getting up to change tapes every
5 minutes.  And it speeds up backups too, so it can't be all bad.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (NetBSD)

iD8DBQFAh+8zEfTEHrP7rjMRAlImAKC1QHaXFlooGGHrV7LqJSx7zBIcqwCfQo2B
hWN9x3+f8TxK8n4KoVFgT9I=
=vHdA
-----END PGP SIGNATURE-----

Alle Zeilen, die sich vor BEGIN PGP SIGNED MESSAGE oder nach END PGP SIGNED MESSAGE befinden, zählen nicht zur signierten Eingabe und werden dementsprechend auch nicht geprüft! Dies ist bspw. in einer eMail der Fall für die Header, da diese ja erst von den Mailservern erweitert/verändert werden. Noch ein Wort zu den eMails: die alte Form der Inlinesignatur ist heute veraltet und sollte nicht mehr eingesetzt werden. Üblicherweise wird nun PGP/MIME eingesetzt, d.h. der Inhalt der eMail (also der verfasste Text und evtl. Anhänge) werden als eigene Dateien verschickt über die die PGP-Signatur gebildet wird.

Daten verschlüsseln

gpg ermöglicht es Daten symmetrisch oder asymmetrisch zu verschlüsseln. Eine Datei lässt sich sehr einfach symmetrische verschlüsseln, d. h. das die verschlüsselte Datei nur entschlüsselt werden kann, wenn man Zugriff auf den verwendeten Schlüssel hat. Im Klartext heißt daß, das die Datei mit einem einfachen Passwort verschlüsselt wird und jeder der Zugriff auf das Passwort hat kann die Datei entschlüsseln. Wir verwenden auch hierbei wieder die Option -a um den bekannten ASCII-Armor zu erzeugen. ACHTUNG: man wird zweimal nach einer Passphrase gefragt, dies ist <b>nicht</b> die Passphrase des privaten Schlüssels, sondern eine neu zu vergebende Passphrase die für diese Datei gültig ist! gpg -a -c date.txt Die Datei wird nun in date.txt.asc verschlüsselt abgelegt und kann auch von einem gpg, das keinerlei Keyrings enthält entschlüsselt werden.

Asymmetrische Verschlüsselung geschieht mit: gpg -a -r 0xb3fbae33 -e date.txt mittels -r wird der Empfänger ausgewählt, nur derjenige, der Zugriff auf den entsprechenden privaten Schlüssel hat, kann date.txt.asc entschlüsseln. Zusätzlich existiert noch eine Option um mehrere Dateien, die verschlüsselt werden sollen, anzugeben: gpg -a -r 0xb3fbae33 --encrypt-files date.txt date2.txt date3.txt

Man sollte Dateien, die verschlüsselt werden, auch zusätzlich mit der Option -s signieren, um deren Integrität zu sichern.

Entschlüsseln lassen sich Daten mit Übergabe der Option -d, man wird dann entweder nach der vergebenen Passphrase für die Datei oder des privaten Schlüssels gefragt. gpg -d date.txt.asc

Signaturen und Verschlüsselung

Schlüssel signieren

$ gpg --sign-key 26B3CFA2 ruft die Shell auf um den Schlüssel 26B3CFA2 mit der eigenen Haupt-ID zu signieren. Hierbei werden die Daten des Zielschlüssels angezeigt und gpg fragt danach wie sorgfältig die Signatur geprüft wurde. Hierbei sollte man sorgfältig und ehrlich arbeiten, da sich über diese Angabe die Vertrauenswürdigkeit des Schlüssels berechnet. Stufe 3 setzt auf alle Fälle eine sorgfältige Prüfung des Schlüssels und der Person (per Personalausweis) voraus.

Danach fragt gpg wie üblich nach der Passphrase und signiert den Zielschlüssel. Diesen kann man nun mit $ gpg --send-key 26B3CFA2 an den Keyserver übertragen oder mit `$ gpg -a --export 26B3CFA2 > 26B3CFA2.asc ` in eine Datei schreiben, die an den Besitzer geschickt wird.

Es bietet sich an, die Datei mit dem signierten Schlüssel verschlüsselt an den Empfänger zu schicken, da dieser, um an die Signatur heranzukommen, die eMail abrufen und die Datei entschlüssen muss. Dies setzt den Zugriff auf die eMailadresse und den privaten Schlüssel voraus und macht Challenge-Response überflüssig.

Eigene Schlüssel, die man zugeschickt bekommt, kann man mit $ gpg --import key.asc in den eigenen Schlüsselring importieren und auf Wunsch danach an einen Keyserver senden.

Web Of Trust

Die Signaturen eines Schlüssels lassen sich als Graph abbilden indem die Schlüssel als Knoten und die Signaturen als Kanten dargestellt werden. Da hierbei Pfade entstehen, lassen sich Beziehungen von Schlüsseln in diesem Web Of Trust leicht nachvollziehen bzw. berechnen.

Das lokale Web of Trust als Graph, erzeugt mit gpg2dot und dot.

F610A67A wurde von B3FBAE33 signiert
F610A67A wurde von A2750458 signiert
A2750458 wurde von F610A67A signiert

Mutt und GnuPG

mutt

mutt ist der wohl z. Zt brauchbarste eMailclient und bietet ziemlich gute gpg Unterstützung.

mutt ist konsolenbasiert und verwendet einfache rc-files um konfiguriert zu werden. Man kann eine Vielzahl von gpg Optionen in .muttrc einstellen oder besser noch, diese in einer Extradatei (bspw. .gpg.rc) angeben und von .muttrc sourcen lassen.

gpg Optionen:

gpg Konfiguration einlesen (in .muttrc):

source  ~/.gpg.rc

gpg Konfiguration (in .gpg.rc)

set pgp_autosign		# alsways sign each message
set pgp_replysign     # always sign reply to signed message
set pgp_replyencrypt  # always encrypt reply to encrypted message
set pgp_replysignencrypted # yeah
set pgp_verify_sig    # always verify pgp signatures
unset pgp_show_unusable # Show non-usable keys on the PGP key selection menu?
unset pipe_decode       # Weed headers and PGP-decode message before piping
# decode application/pgp
set pgp_decode_command="gpg   %?p?--passphrase-fd 0? --no-verbose --quiet  --batch  --output - %f"

# verify a pgp/mime signature
set pgp_verify_command="gpg   --no-verbose --quiet  --batch  --output - --verify %s %f"

# decrypt a pgp/mime attachment
set pgp_decrypt_command="gpg   --passphrase-fd 0 --no-verbose --quiet  --batch  --output - %f"

# create a pgp/mime signed attachment
# set pgp_sign_command="gpg-2comp --comment '' --no-verbose --batch  --output - --passphrase-fd 0 --armor --detach-sign --textmode %?a?-u %a? %f"
set pgp_sign_command="gpg    --no-verbose --batch --quiet   --output - --passphrase-fd 0 --armor --detach-sign --textmode %?a?-u %a? %f"

# create a application/pgp signed (old-style) message
# set pgp_clearsign_command="gpg-2comp --comment ''  --no-verbose --batch  --output - --passphrase-fd 0 --armor --textmode --clearsign %?a?-u %a? %f"
set pgp_clearsign_command="gpg   --batch --quiet   --output - --passphrase-fd 0 --armor --textmode --clearsign %?a?-u %a? %f"

# create a pgp/mime encrypted attachment
# set pgp_encrypt_only_command="pgpewrap gpg-2comp  -v --batch  --output - --encrypt --textmode --armor --always-trust -- -r %r -- %f"
set pgp_encrypt_only_command="pgpewrap gpg    --batch  --quiet  --no-verbose --output - --encrypt --default-recipient-self --encrypt-to b3fbae33 --textmode --armor --always-trust -- -r %r -- %f"

# create a pgp/mime encrypted and signed attachment
# set pgp_encrypt_sign_command="pgpewrap gpg-2comp  --passphrase-fd 0 -v --batch  --output - --encrypt --sign %?a?-u %a? --armor --always-trust -- -r %r -- %f"
set pgp_encrypt_sign_command="pgpewrap gpg  --passphrase-fd 0  --batch --quiet  --no-verbose  --textmode --output - --encrypt --default-recipient-self --encrypt-to b3fbae33 --sign %?a?-u %a? --armor --always-trust -- -r %r -- %f"

# import a key into the public key ring
set pgp_import_command="gpg  --no-verbose --import -v %f"

# export a key from the public key ring
set pgp_export_command="gpg   --no-verbose --export --armor %r"

# verify a key
set pgp_verify_key_command="gpg   --verbose --batch  --fingerprint --check-sigs %r"

# read in the public key ring
set pgp_list_pubring_command="gpg   --no-verbose --batch --quiet   --with-colons --list-keys %r"

# read in the secret key ring
set pgp_list_secring_command="gpg   --no-verbose --batch --quiet   --with-colons --list-secret-keys %r"

# fetch keys
# set pgp_getkeys_command="pkspxycwrap %r"

# pattern for good signature - may need to be adapted to locale!

# set pgp_good_sign="^gpg: Good signature from"

# OK, here's a version which uses gnupg's message catalog:
set pgp_good_sign="`gettext -d gnupg -s 'Good signature from "' | tr -d '"'`"

set pgp_sign_as="0xB3FBAE33"

Es gibt zu mutt und GPG unzählige Hilfeseiten und Beispielkonfigurationen im WWW und Usenet, eine geeignete Suchmaschine wirkt hier geradezu Wunder.

Links

Linksammlung entfernt (2025-04-21)

GnuPG Kurzreferenz

Zum Ausdrucken habe ich eine einseitige GnuPG-Referenz erstellt: gpg-referenz.pdf

Den $\LaTeX$-Code gibt es hier: gpg-referenz.tex