GnuPG
Dieser Artikel wurde für die folgenden Ubuntu-Versionen getestet:
Ubuntu 22.04 Jammy Jellyfish
Du möchtest den Artikel für eine weitere Ubuntu-Version testen? Mitarbeit im Wiki ist immer willkommen! Dazu sind die Hinweise zum Testen von Artikeln zu beachten.
Zum Verständnis dieses Artikels sind folgende Seiten hilfreich:
Dieser Artikel behandelt die Signatur und Verschlüsselung mit Hilfe des freien Kryptografie-Systems GNU Privacy Guard (GnuPG) 🇬🇧. Alle unter Linux gängigen Mailprogramme wie Evolution, Kmail oder Thunderbird können GnuPG zur Verschlüsselung von E-Mails nach dem OpenPGP-Standard nutzen. Ab Version 2.x unterstützt GnuPG auch den S/MIME-Standard.
Achtung!
In nicht mehr aktuellen Ubuntu-Versionen kommt standardmäßig noch die alte 1.4-Version von GnuPG zum Einsatz. Dieser Versionszweig sollte nicht mehr benutzt werden und wird vom Projekt auch nicht mehr vollständig weitergepflegt. Neuere Ubuntu-Versionen (seit Ubuntu 17.10) haben diese Umstellung bereits nachvollzogen und verwenden standardmäßig die 2-er Version.
Welche Version von GnuPG standardmäßig zum Einsatz kommt, kann auf der Kommandozeile wie folgt überprüft werden:
$ gpg --version
gpg (GnuPG) 1.4.20
Hier sollte man das Paket gnupg2 nachinstallieren und auf der Kommandozeile statt "gpg" immer den Befehl "gpg2" verwenden.
$ gpg --version
gpg (GnuPG) 2.2.4
Hier wird bereits standardmäßig GnuPG Version 2.x verwendet.
Um Verwechslungen zu vermeiden wird im folgenden Artikel explizit der Befehl "gpg2" verwendet.
Um E-Mails mit GnuPG signieren oder verschlüsseln zu können, benötigt man ein eigenes Schlüsselpaar. Das Schlüsselpaar besteht aus einem öffentlichen und einem privaten Schlüssel.
Während der öffentliche Schlüssel weitergegeben wird, um den Kommunikationspartnern zu ermöglichen, Daten verschlüsselt an sie zu versenden oder ihre Signatur zu überprüfen, muss der private Schlüssel vom Besitzer geheim gehalten werden, damit nur dieser die Daten entschlüsseln bzw. signieren kann.
Die grundlegenden Prinzipien der verwendeten Technik zu verstehen, trägt zur sicheren Anwendung des Verfahrens bei. Diesem Thema widmet sich der Hintergrundartikel GnuPG/Technischer Hintergrund. Wer noch nicht mit der Funktionsweise asymmetrischer Verschlüsselungssysteme vertraut ist, sollte sich diesen Artikel auf jeden Fall zu Gemüte führen, bevor er hier weiterliest [4]. Weitere Grundlagenartikel sind unten unter Links zu finden.
Dieser Artikel beschäftigt sich mit der asymmetrischen Verschlüsselung mit GnuPG, wer sich für die symmetrische Verschlüsselung mit GnuPG interessiert, muss hier weiterlesen GnuPG/Symmetrische Verschlüsselung.
Installation¶
Das Paket gnupg ist bei allen derzeitigen Ubuntu-Versionen vorinstalliert. Seit Ubuntu 17.10 handelt es sich bereits um GnuPG Version 2.
Für ältere Ubuntu-Versionen installiert man die Version 2 von GnuPG wie folgt nach:
gnupg2
Befehl zum Installieren der Pakete:
sudo apt-get install gnupg2
Oder mit apturl installieren, Link: apt://gnupg2
Grafische Programme zur Schlüsselverwaltung¶
Unter Gnome/Unity dient das Programm Seahorse (bzw."Passwörter und Verschlüsselung") zur grafischen Schlüssel- und Passwortverwaltung.
Unter KDE steht dafür das Programm KGpg zur Verfügung.
GPA ist nicht für eine bestimmte Desktop-Umgebung ausgelegt und eignet sich deswegen auch besonders für den Einsatz auf "leichten" Systemen.
GnuPG in anderen Programmen nutzen¶
Eigentlich können unter Linux alle gängigen E-Mail-Programme GnuPG zur Verschlüsselung und Signierung von E-Mails nutzen. Auch einige andere Programme, bspw. Instant Messenger, sind GnuPG-fähig. Wie man das im Einzelfall nutzen kann, steht in den jeweiligen Artikeln bzw. der Dokumentation der jeweiligen Programme. Hier eine Tabelle mit direkten Links zur GnuPG-Funktionalität:
| Programm | Kategorie |
| Evolution (Abschnitt „GnuPG“) | |
| KMail | |
| Sylpheed (Abschnitt „E-Mails-verschluesseln-mit-GnuPG“) | |
| Claws Mail | |
| Gajim (Abschnitt „c2c-Verschluesselung“) | Jabber/Instant Messenger |
| Psi (Abschnitt „Verschluesselung“) | Jabber/Instant Messenger |
| Kopete (Abschnitt „Module“) | Jabber/Instant Messenger |
| MCabber (Abschnitt „Verschluesselung“) | Jabber/Instant Messenger |
Dabei ist es sinnvoll oder teilweise auch nötig, den GPG-Agent zur Passwortverwaltung zu benutzen.
Der Schlüsselbund¶
GnuPG speichert alle Schlüssel, die man mit der Zeit sammelt, in einem "Schlüsselbund" im Verzeichnis ~/.gnupg/. Vormalig befanden sich dort zwei Schlüsselbunde, pubring.gpg für die öffentlichen Schlüssel und secring.gpg für die Privaten. Dies wurde jedoch mit Version 2.1 entfernt.
Die privaten Schlüssel befinden sich nun in dem Verzeichnis private-keys-v1.d/, während die Datei pubring.kbx die öffentlichen Schlüssel enthält.
Für die Ordnerstruktur von .gnupg/ sowie die Konfigurationsdateien siehe auch den Artikel zur GPG-Konfiguration.
Alle GnuPG-Operationen werden mit dem Kommandozeilenwerkzeug gpg durchgeführt [1].
Wer seinen GnuPG-Schlüsselbund nicht über die Kommandozeile verwalten möchte, findet in den Ubuntu-Repositories eine Reihe grafischer Schlüsselbundmanager (Frontends), die aber nicht im Fokus dieses Artikels stehen. Unter KDE gibt es beispielsweise das Werkzeug KGpg, dem ein eigener Artikel gewidmet ist.
Nutzer von GNOME möchten dagegen vielleicht lieber Seahorse verwenden, ein Programm, das auch mit dem Dateimanager (Nautilus) und dem Texteditor von GNOME (gedit) zusammenarbeitet - ausführlich beschrieben im Artikel Seahorse.
Unter Ubuntu-Mate (evt. auch anderen GNOME Varianten) ist Seahorse unter "Passwörter und Verschlüsselung" unter Zubehör im "Brisk Menü Starter" zu finden.
Vom GnuPG-Projekt selbst stammt der "GNU Privacy Assistant" (GPA), der auf dem GIMP-Toolkit basiert, aber desktop-unabhängig ist. Mehr Informationen dazu liefert der Artikel GPA.
Möchte man seine Schlüssel anstatt in ~/.gnupg/ lieber woanders aufheben, nutzt man bei der Verwendung von gpg2 die Option --homedir /mein/pfad/zum/gnupg oder setzt global oder pro Anwender die Umgebungsvariable GNUPGHOME=/mein/pfad/zum/gnupg.
Schlüssel auflisten¶
Bei den nachfolgenden gpg-Befehlen auf der Kommandozeile (Terminal) ist die Reihenfolge der gpg-Optionen bei den gezeigten Beispielen genau einzuhalten, da das Programm hier andernfalls unerwartet arbeitet. Mit folgenden Befehlen kann man seine GPG-Schlüssel auflisten lassen. Die Optionen können dabei jeweils in der langen, beschreibenden Version oder in der kurzen, einbuchstabigen Variante benutzt werden. Entweder die eigenen, geheimen Schlüssel:
gpg2 --list-secret-keys gpg2 -K
oder die öffentlichen Schlüssel:
gpg2 --list-keys gpg2 -k
Diese Befehle zeigen Informationen über die Schlüssel an. Wichtig ist hierbei u.a. die Key-ID (hinter der "Schlüsselstärke" zu finden). Es ist ein achtstelliger Hex-Code.
sec 1024D/ABCD1234 2005-06-18 Max Mustermann <max.m _at_ example.com>
In diesem Beispiel ist die Key-ID ABCD1234. Wenn man bisher weder eigene Schlüssel angelegt noch fremde importiert hat, ist die Ausgabe natürlich leer.
Neuere Versionen von GPG geben statt der kurzen 8-stelligen Key-ID nur den 40-stelligen Fingerprint der Schlüssel aus. Will man dennoch die kurze Key-ID haben, so verwendet man diesen Befehl:
gpg2 --list-keys --keyid-format SHORT
"Fingerprint" anzeigen¶
Ein Fingerprint (dt.: Fingerabdruck) ist ein relativ kurzer Hash-Wert, mit dem man Schlüssel verifizieren kann. Dieser identifiziert einen Schlüssel, so wie der menschliche Fingerabdruck einen Menschen (praktisch) eindeutig identifiziert. Nach heutigem Kenntnisstand ist es so gut wie aussichtslos zu versuchen, einen zweiten Schlüssel mit demselben Fingerprint zu erschaffen. Man kann (und sollte) das dafür nutzen, sich von der Echtheit solcher Schlüssel zu überzeugen, die man von einem Schlüssel-Server oder per E-Mail erhalten hat. Dieser Fingerabdruck besteht aus einer Zeile Hexadezimalzahlen, die man bspw. auf Visitenkarten drucken oder am Telefon übermitteln kann.
Anzeigen lässt sich der Fingerabdruck eines Schlüssels mit:
gpg2 --fingerprint <ID oder Name des Schlüssels>
So sieht er etwa aus: 23C7 B473 4C46 5AFB B0D3 E60F 631E 9BDA E8D8 4F17
Die Ausgabe dieses Kommandos sieht genauso aus wie die von --list-keys, mit einer zusätzlichen Zeile. Man kann die ID auch weglassen, dann werden alle Schlüssel des Schlüsselbunds mit Fingerabdruck aufgeführt.
Mit dem folgenden Befehl kann der Fingerabdruck einer Schlüsseldatei angezeigt werden, ohne sie in den Schlüsselbund zu importieren:
gpg2 --with-fingerprint /tmp/dateiname.asc
Schlüsselpaar erzeugen¶
Ein neues Schlüsselpaar aus privatem und zugehörigem öffentlichen Schlüssel kann ganz einfach im Terminal [1] erzeugt werden:
gpg2 --full-gen-key
Bitte wählen Sie, welche Art von Schlüssel Sie möchten: (1) RSA und RSA (voreingestellt) (2) DSA und Elgamal (3) DSA (nur unterschreiben/beglaubigen) (4) RSA (nur signieren/beglaubigen) Ihre Auswahl?
Sind pro Option mehr als ein Algorithmus angegeben, so bezieht sich der erste auf das Signieren und der zweite auf das Verschlüsseln. Bei der Wahl der Art des Schlüssels (bzw. der Schlüssel) sollte allerdings nur mit entsprechendem Hintergrundwissen von der Standardauswahl abgewichen werden.
Experten-Info:
Es ist z.B. möglich einen RSA-Signierschlüssel mit einem ElGamal-Verschlüsselungsschlüssel zu wählen. Dazu müsste man 4 auswählen und später dem RSA-Schlüsselpaar ein ElGamal-Unterschlüsselpaar hinzufügen (Stichwort: addkey).
Anschließend wird die Schlüsselstärke erfragt. Je nach Art des Schlüssels sind unterschiedliche Werte möglich. Der mögliche Mini- bzw. Maximalwert wird vom Programm ausgegeben. Je höher dieser Wert, desto sicherer - aber auch umso langsamer - "arbeitet" der Schlüssel. Der vorgeschlagene Wert von 3072 ist für die meisten Anwendungsfälle in Ordnung und kann übernommen werden.
Hinweis:
Um auf Nummer sicher zu gehen, empfehlen verschiedene Kryptographen heutzutage eine Schlüssellänge von 3072 Bits oder mehr.
RSA-Schlüssel können zwischen 1024 und 4096 Bits lang sein. Welche Schlüssellänge wünschen Sie? (3072)
Anschließend muss man auswählen, wie lange der Schlüssel gültig sein soll. Hier sollte man der Versuchung widerstehen, eine unbeschränkte Gültigkeit festzulegen, da dieser Schlüssel dann auch bei Verlust ewig gültig ist und niemals von den Schlüssel-Servern ("keyserver") verschwindet. Irgend etwas zwischen 1 und 5 Jahren ist dagegen ein praktischer Wert. Für ein Gültigkeitsdauer von einem Jahr gibt man als Wert "1y" ein und bestätigt mit ⏎ .
Bitte wählen Sie, wie lange der Schlüssel gültig bleiben soll.
0 = Schlüssel verfällt nie
<n> = Schlüssel verfällt nach n Tagen
<n>w = Schlüssel verfällt nach n Wochen
<n>m = Schlüssel verfällt nach n Monaten
<n>y = Schlüssel verfällt nach n Jahren
Wie lange bleibt der Schlüssel gültig? (0)Hinweis:
Das Ablaufdatum kann auch noch nachträglich geändert werden. Um diese Änderungen seinen Gesprächspartnern mitzuteilen, muss man ihnen seinen öffentlichen Schlüssel erneut schicken bzw. ihn erneut zum Schlüsselserver hochladen.
Nun müssen der Name und die E-Mail-Adresse angegeben werden, für die das Schlüsselpaar gelten soll:
Sie benötigen eine Benutzer-ID, um Ihren Schlüssel eindeutig zu machen; das
Programm baut diese Benutzer-ID aus Ihrem echten Namen, einem Kommentar und
der E-Mail-Adresse in dieser Form auf:
"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"
Ihr Name ("Vorname Nachname"): Vorname Nachname
E-Mail-Adresse: user@example.com
Kommentar: optional
Sie haben diese User-ID gewählt:
"Vorname Nachname (optional) <user@example.com>"
Ändern: (N)ame, (K)ommentar, (E)-Mail oder (F)ertig/(B)eenden?Schließlich wird nochmal gefragt, ob die Angaben in Ordnung sind (mit der Taste F bestätigen,), und eine Passphrase für den privaten Schlüssel wird benötigt, um diesen zu schützen. Diese Passphrase benötigt man später, um Mails zu signieren und zu entschlüsseln. Dieser Passwort-Satz sollte nicht leicht zu erraten sein; Tipps findet man z.B. im Sicherheits 1x1 (Abschnitt „Passwoerter“). Nun wird der Schlüssel erstellt, wobei eine große Menge echter (nicht Pseudo-)Zufallswerte benötigt werden. Es kann deswegen sein, dass man vom System gebeten wird, ein wenig mit Maus und Tastatur zu spielen, um solche Werte besser erzeugen zu können.
Hinweis:
Oftmals hat ein System - vor allem bei großen Schlüssellängen - Probleme, ausreichend viele Zufallswerte zu generieren. Hierbei kann das Programm haveged unterstützend wirken. Dieses kann ganz einfach via sudo apt-get install haveged installiert werden, danach „sammelt“ der Dienst im Hintergrund zufällige Ereignisse.
Mehr Infos zur Funktionsweise u. a. hier:
Nun liegt der Schlüssel in ~/.gnupg/private-keys-v1.d/ unter der zugehörigen ID, und man kann ihn wie oben beschrieben auflisten lassen. Mit dem öffentlichen Schlüssel verschlüsselte Nachrichten oder auch Dateien können nur mittels des dazugehörigen privaten Schlüssel wieder entschlüsselt werden. Genauere Details finden sich im Artikel GnuPG/Technischer Hintergrund.
Achtung!
Wenn man plant, den Schlüssel an mehr als ein paar Leute weiterzugeben (bzw. ihn auf einen Keyserver hochzuladen), denen man bei Verlust oder Kompromittierung des privaten Schlüssels persönlich Bescheid sagen kann, sollte man sich am besten direkt nach der Erstellung des Schlüssels ein sogenanntes Widerrufszertifikat erstellen, mit dem man später den Schlüssel - auch ohne dass dieser vorhanden sein muss - für ungültig erklären kann. (mehr)
ECC Schlüssel¶
gpg2 kann auch ECC-Schlüssel erzeugen:
gpg2 --expert --full-gen-key
Sinnvoll sind dabei diese Parameter:
Please select what kind of key you want: ... (9) ECC and ECC ...
Please select which elliptic curve you want: (1) Curve 25519 ...
Allerdings sind ECC-Keys nicht mit älteren Versionen von GnuPG kompatibel. Bei der Nutzung von ECC-Schlüsseln sollte man dementsprechend wissen, was man tut.
Schlüssel importieren¶
Erhält man den öffentlichen Schlüssel eines Kommunikationspartners oder will man ein Schlüsselpaar (also einen privaten und einen öffentlichen Schlüssel) importieren, so muss man ihn zur weiteren Verwendung zunächst in den Schlüsselbund importieren.
Man sollte aber auf keinen Fall Schlüssel ungeprüft verwenden! Entweder man nimmt persönlichen Kontakt zum Kommunikationspartner auf und gleicht den "fingerprint" ab, oder man nutzt das GnuPG/Web of Trust.
gpg2 --with-fingerprint /tmp/dateiname.asc
gpg2 --import /tmp/dateiname.asc
Schlüssel exportieren¶
Ebenso kann man einen Schlüssel exportieren. Das ist z.B. notwendig, wenn man seinen öffentlichen Schlüssel auf seiner Webseite zum freien Herunterladen anbieten will, oder wenn man den Schlüssel eines Kommunikationspartners signiert hat und ihm diesen jetzt mit dieser Signatur zukommen lassen möchte (siehe auch GnuPG/Web of Trust).
gpg2 -a --output gpg-key.asc --export <optional Schlüssel-ID oder Name>
Der Schlüssel befindet sich danach in der Datei gpg-key.asc im aktuellen Verzeichnis und kann als E-Mail-Anhang verschickt oder auf irgendwo hochgeladen werden. Bei dieser Befehlsvariante wird der private Teil eines Schlüsselpaares - falls vorhanden - nicht exportiert.
Um auch private Schlüssel zu exportieren, müssen andere Befehlsoptionen verwendet werden. Dies dient dazu, ein versehentliches Veröffentlichen des privaten Schlüssels zu verhindern. Der folgende Befehl sollte also nur mit Bedacht verwendet werden:
gpg2 -a --output gpg-secret-key.asc --export-secret-keys <optional Schlüssel-ID oder Name>
Schlüssel suchen¶
Es kann auch ein öffentlicher Schlüssel von einem Schlüssel-Server (Keyserver) abgerufen werden. Dazu sind zwei Parameter wichtig. Der Schlüsselserver der kontaktiert werden soll, und nach welchen Schlüsselwörtern gesucht werden soll, bspw. E-Mail oder Name des Kontakts.
gpg2 --keyserver <keyserver> --search-keys <Bezeichnung>
Der Parameter des Keyservers ist dabei nicht unbedingt erforderlich. Wieso das so ist, und noch weitere Informationen zu Schlüssel-Servern, stehen im Wiki-Artikel Web of Trust.
Vertrauensstufe importieren oder exportieren¶
Jedem Schlüssel ist der Grad des Vertrauens in diesen zugewiesen. Auch diese Eigenschaft lässt sich exportieren, um sie z.B. auf einem anderen Rechner wiederzuverwenden. Mehr Informationen zum Thema Vertrauen findet man im Artikel GnuPG/Web of Trust.
Das Exportieren dieser Informationen geschieht mit dem Befehl
gpg2 --export-ownertrust > trust.txt
Zu beachten ist, dass hierbei die Information zu jedem Schlüssel im Schlüsselring exportiert wird. Eine Einschränkung ist nicht möglich.
Eine so erzeugte Datei kann anschließend mit
gpg2 --import-ownertrust < trust.txt
importiert werden.
Zusätzliche E-Mail-Adressen¶
Viele Leute besitzen inzwischen mehrere E-Mail-Adressen, aber die wenigsten wollen für jede einen eigenen Schlüssel erzeugen und sich alle unterschiedlichen Passphrasen merken. Deswegen kann man dem eigenen Schlüsselpaar zusätzliche Identitäten hinzufügen. Der Schlüssel gilt dann für alle diese E-Mail-Adressen. Das geht so:
gpg2 --edit-key <Schlüssel-ID oder Name> Befehl> adduid
Dann auf Nachfrage den neuen Namen (bzw. denselben), die zusätzliche E-Mail-Adresse und optional einen zugehörigen Kommentar angeben, mit F bestätigen und die Passphrase des Schlüssel eingeben. Danach das Schlüssel-Edit-Programm verlassen:
Befehl> save
Der Schlüssel ist jetzt mit der zusätzlichen Identität verknüpft, was man durch einen Aufruf von gpg2 --list-keys überprüfen kann.
Konfiguration der bevorzugten Algorithmen¶
Achtung!
Wie bei der Erzeugung des Schlüsselpaares, sollte auch hier nur mit dem nötigen Hintergrundwissen von den Standardeinstellungen abgewichen werden. Außerdem sollten die Beispiele nicht gedankenlos übernommen werden, da sie recht willkürlich gewählt wurden.
GnuPG unterstützt mehrere Algorithmen zur symmetrischen Verschlüsselung zum Signieren und Komprimieren von Nachrichten. Welche unterstützt werden, lässt sich mittels
gpg2 --version
ermitteln.
Welche Algorithmen beim Senden einer Nachricht verwendet werden, hängt davon ab, wie sich Sender und Empfänger einigen. Dazu legen Sender und Empfänger jeweils eine Liste bevorzugter Algorithmen an, welche verglichen werden.
Der Empfänger hinterlegt seine Vorzugsliste in seinem öffentlichen Schlüssel. Um sich seine eigenen Einstellungen anzeigen zu lassen, geht man wie folgt vor:
gpg2 --edit-key <Schlüssel-ID oder Name> Befehl> showpref
Die Ausgabe sieht in der Standardeinstellung von GnuPG und unveränderten Schlüsseleinstellungen so aus:
[uneingeschränkt] (1). foo bar <foo@bar.com>
Verschlü.: AES256, AES192, AES, CAST5, 3DES, IDEA
Digest: SHA256, SHA1, SHA384, SHA512, SHA224
Komprimierung: ZLIB, BZIP2, ZIP, nicht komprimiert
Eigenschaften: MDC, Keyserver no-modify Um nun diese Liste zu editieren, steht der Befehl setpref zur Verfügung. Dem Befehl selbst folgt direkt eine Liste bevorzugter Algorithmen, also z.B.:
Befehl> setpref AES256 SHA512 SHA256 BZIP2 ZLIB
Liste der Voreinstellungen setzen:
Verschlü.: AES256, AES, 3DES
Digest: SHA512, SHA256, SHA1
Komprimierung: BZIP2, ZLIB, nicht komprimiert
Eigenschaften: MDC, Keyserver no-modify
Die Voreinstellungen wirklich ändern? (j/N) Durch Drücken von J bestätigt man seine angezeigte Eingabe und muss nach Eingabe seines Passworts den Schlüssel speichern:
Befehl> save
Experten-Info:
GnuPG fügt der Liste automatisch 3DES, SHA1 und nicht komprimiert hinzu. Diese Algorithmen werden benutzt, wenn eine Einigung zwischen Sender und Empfänger fehlschlägt.
Der Sender legt seine Vorlieben für den Versand in der Konfigurationsdatei von GnuPG fest. Dazu fügt er z.B. folgendes an das Ende der Datei ~/.gnupg/gpg.conf an:
#Bevorzugte Verschlüsselungsalgorithmen personal-cipher-preferences AES256 #Bevorzugte Hashalgorithmen personal-digest-preferences SHA384 #Bevorzugte Kompressionsalgorithmen personal-compress-preferences BZIP2
Beim Versand einer Nachricht vergleicht nun GnuPG die Liste des Senders mit der Liste des Empfängers und wählt den ersten übereinstimmenden Algorithmus aus (hier den symmetrischen Verschlüsselungsalgorithmus):
| Liste des Senders: | AES256, AES |
| Liste des Empfänges: | TWOFISH, AES256, AES |
Kann auf diese Art und Weise keine Einigung erzielt werden, wird, wie oben bereits erwähnt, 3DES zur Verschlüsselung, SHA1 zum Signieren und keine Kompression verwendet. Die genaue Bedeutung der o.g. GnuPG Optionen kann in der offiziellen Dokumentation nachgeschlagen werden.
Dateioperationen¶
Mit den folgenden Befehlen kann man Dateien mit GnuPG verschlüsseln oder digital signieren. In den meisten Fällen, wenn man GnuPG z.B. für die E-Mail-Kommunikation benutzt, braucht man sich mit diesen Optionen aber nicht weiter zu beschäftigen, da die Mail-Programme sich selbst um die Verschlüsselung kümmern. Die folgenden Befehle benötigt man also nur, wenn man bspw. Dateien verschlüsselt auf der eigenen Festplatte speichern will oder wenn man ein Softwarepaket, welches man auf der eigenen Homepage anbietet, digital signieren will.
In den folgenden Beispielen wird davon ausgegangen, dass man eine fiktive Datei test.txt behandeln will.
Verschlüsseln¶
Wenn man etwas verschlüsseln will, muss auch angegeben werden, für wen das geschehen soll. (Genauer gesagt, mit wessen öffentlichem Schlüssel die Datei verschlüsselt werden soll.) Der Befehl hierfür sieht wie folgt aus:
gpg2 --encrypt -a --recipient <Name oder Key_Id> test.txt
Es entsteht eine Datei test.txt.asc.
Hinweis:
Wenn man die Datei mit dem öffentlichen Schlüssel von jemand anderem verschlüsselt hat, bedeutet dies, dass nur derjenige die Datei wieder entschlüsseln kann. Selber kann man dies nicht, da man nicht im Besitz des geheimen Schlüssels des Kommunikationspartners ist. Wenn man die Daten selber noch benötigt, sollte man also eine Kopie der unverschlüsselten Datei behalten. Alternativ kann diese zusätzlich mit dem eigenen Schlüssel verschlüsselt werden - die Option --recipient kann mehrfach angegeben werden.
Entschlüsseln¶
Der Inhaber des privaten Schlüssels kann diese Datei jetzt auf folgende Weise wieder in die ursprüngliche Version verwandeln. (Hierfür wird natürlich die Passphrase benötigt.)
gpg2 --decrypt --output entschluesselt.txt test.txt.asc
In entschluesselt.txt steht nun wieder der Text. Wenn man den Parameter --output (und den Dateinamen) weglässt, gibt GnuPG den entschlüsselten Text im Terminal aus.
Hinweis:
Anstelle der langen Optionsnamen --encrypt, --decrypt, --recipient und -output kann man auch die Kurzversionen -e, -d, -r und -o verwenden. Die Option -a, ausgeschrieben --armor bedeutet, dass die verschlüsselte Datei im ASCII-Armor-Format gespeichert wird. Lässt man diese Option weg, wird das Ergebnis in einem Binärformat abgelegt und erhält die Endung .gpg bzw. bei Signaturen .sig, anstatt .asc.
Die Ausgabe im ASCII-Armor-Format benötigt 33 Prozent mehr Speicherplatz als die im Binärformat, enthält jedoch nur druckbare Zeichen. Sie eignet sich daher besser zum Übertragen über das Internet, wie etwa bei E-Mails oder zum Einbinden in HTML-Seiten. Sollen die Daten hingegen verschlüsselt auf der Festplatte abgelegt werden, ist das Binärformat gerade bei großen Dateien vorzuziehen.
Im Internetgebrauch sollte man sich daher den Einsatz der Option -a angewöhnen.
Signieren¶
Es gibt mehrere Verfahren, eine Datei digital zu signieren. In den meisten Fällen wird man die folgende Option verwenden:
gpg2 --detach-sig -a test.txt
Nachdem man seine Passphrase erfolgreich eingegeben hat, erhält man eine Datei test.txt.asc. Diese enthält eine digitale Signatur der Originaldatei mit der sich die Authentizität beweisen lässt. Hier ein Beispiel:
-----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.1 (GNU/Linux) iD8DBQFDTqEJxHY64NcyylkRAvZ2AJoDxlQ4VuqpIDfcTFnHEye4PGfNIACdEcRw QVoj5npyj4VyaEzLzx4vdSs= =ySv1 -----END PGP SIGNATURE-----
Man kann auch die Kurzform -b verwenden. Verwendet man stattdessen die Option --clearsign, so wird nicht nur die Signatur in die Ausgabedatei geschrieben, sondern die ganze Ursprungsdatei mit angehängter Signatur am Ende. Das kann praktisch sein, wenn man nur eine einzige Datei übertragen will. Allerdings muss dann der Empfänger im Falle von ausführbarem Code diese Signatur erstmal wieder aus der Datei entfernen, um sie verwenden zu können. Siehe auch das GnuPG-Manual.
Zum Signieren wird immer der default-Schlüssel verwendet. Sollte man mehrere geheime Schlüssel besitzen, kann man mit dem Parameter --local-user den Schlüssel angeben, den man für die Signatur verwenden will.
Signatur verifizieren¶
Eine Signatur überprüft man mit folgendem Kommando:
gpg2 --verify test.txt.asc
gpg: Signature made Mon 19 Jun 2006 17:06:05 CEST using DSA key ID <Key_Id> gpg: Good signature from "Person, von der die Signatur stammt"
Wenn die signierte Datei nicht den gleichen Dateinamen wie die Signatur (abzgl. der .asc- oder .sig-Endung) trägt, kann man diesen Dateinamen separat angeben:
gpg2 --verify signaturdatei.asc test.txt
Sollte die Signatur nicht zu dem Text passen, weil die Datei nachträglich manipuliert wurde, wird dies durch BAD signature from... angezeigt. Das dritte mögliche Ergebnis ist, dass GnuPG die Signatur nicht verifizieren kann, weil man den benötigten Schlüssel nicht im Schlüsselbund hat. In diesem Fall muss man sich erstmal den öffentlichen Schlüssel des Absenders besorgen.
Thunar Skripte¶
Wie man bei Thunar benutzerdefinierte Aktionen zum Ver- und Entschlüsseln einrichtet, steht unter Thunar/Benutzerdefinierte Aktionen (Abschnitt „Beispiele“)
E-Mail-Verschlüsselung testen¶
Das GNU Privacy Project 🇩🇪 (GnuPP) stellt einen praktischen Dienst zum Testen verschlüsselter E-Mails bereit: den "freundlichen E-Mail-Roboter Adele". Jeder kann einfach eine unverschlüsselte E-Mail mit dem eigenen öffentlichen Schlüssel - entweder als Anhang oder per Kopieren-und-Einfügen - an adele@gnupp.de senden. Der Betreff sollte "mein öffentlicher Schlüssel" lauten. Adele antwortet dann mit einer verschlüsselten E-Mail, die im folgenden Beispiel bereits entschlüsselt wurde:
Hallo VORNAME NAME, hier ist die verschlüsselte Antwort auf Ihre E-Mail. Ihr öffentlicher Schlüssel mit der Schlüssel-ID 123456789ABCDEFG und der Bezeichnung `VORNAME NAME <E-MAIL-ADRESSE>' wurde von mir empfangen. Anbei der öffentliche Schlüssel von adele@gnupp.de, dem freundlichen E-Mail-Roboter. Viele Grüße, adele@gnupp.de
In dieser Antwort ist zusätzlich Adeles öffentlicher Schlüssel enthalten. Den Text zwischen und einschließlich der Zeilen:
-----BEGIN PGP PUBLIC KEY BLOCK----- -----END PGP PUBLIC KEY BLOCK-----
kopieren und in eine Textdatei mit der Endung adele_public_key.asc speichern, um diesen importieren zu können.
Nun kann man im zweiten Schritt selbst eine verschlüsselte Nachricht an Adele senden, die von Adele wiederum verschlüsselt beantwortet wird. Für diese zweite E-Mail muss Adeles öffentlicher Schlüssel aber zuerst in den eigenen Schlüsselbund importiert werden (siehe oben).
Texte per Zwischenablage Ver-/Entschlüsseln¶
Um beliebige Texte (auch z.B. für beliebige E-Mail-Programme) zu ver-/entschlüsseln oder zu signieren, können mit dem Programm xsel Texte über die Zwischenablage entsprechend bearbeitet werden. Im Folgenden sind drei Bash-Skripte aufgeführt, welche den Inhalt der Zwischenablage (i.d.R. via Strg + C befüllen) verschlüsseln, entschlüsseln oder signieren:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 | #!/bin/bash # Verschlüsseln von Text. # Erforderliche Linux Pakete: gpg, xsel usage() { cat << EOF usage: $0 options Dieses Script verschlüsselt mit OpenPGP Text in der Zwischenablage und gibt ihn in eine Datei oder die Standardausgabe aus. Damit die Ausgabe zusätzlich in eine Datei ausgegeben wird, muss das Script mit der Option -o aufgerufen werden. -m Angabe der Empfänger E-Mailadresse EOF } while getopts .hom:. OPTION do case $OPTION in h) usage exit 1 ;; o) Dateiausgabe="true" ;; m) Mail="${OPTARG}" ;; ?) usage exit ;; esac done echo "Clipboard-Inhalt vor Verschlüsselung:" echo "*************************************" echo "" xsel --clipboard echo "" echo "" echo "" echo "Mit GnuPG verschlüsseln ...:" echo "****************************" echo "" xsel --clipboard | gpg2 --verbose --encrypt -a --recipient $Mail | xsel --clipboard echo "" echo "" echo "" echo "Clipboard-Inhalt nach Verschlüsselung:" echo "**************************************" echo "" xsel --clipboard if [[ "$Dateiausgabe" == true ]]; then xsel --clipboard > encrypted.txt fi # Only works with bash (and not sh): echo "" echo "" echo "" read -s -n 1 -p "Press any key to continue…" |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 | #!/bin/bash # Entschlüsseln von Text. # Erforderliche Linux-Pakete: gpg, xsel usage() { cat << EOF usage: $0 options Dieses Script entschlüsselt mit OpenPGP verschlüsselten Text in der Zwischenablage und gibt ihn in eine Datei oder die Standardausgabe aus. Damit die Ausgabe zusätzlich in eine Datei ausgegeben wird, muss das Script mit der Option -o aufgerufen werden. EOF } while getopts .ho. OPTION do case $OPTION in h) usage exit 1 ;; o) Dateiausgabe="true" ;; ?) usage exit ;; esac done echo "Clipboard-Inhalt vor Entschlüsselung:" echo "*************************************" echo "" xsel --clipboard echo "" echo "" echo "" echo "Mit GnuPG entschlüsseln ...:" echo "****************************" echo "" xsel --clipboard | gpg2 --verbose --decrypt -a | xsel --clipboard echo "" echo "" echo "" echo "Clipboard-Inhalt nach Entschlüsselung:" echo "**************************************" echo "" xsel --clipboard if [[ "$Dateiausgabe" == true ]]; then xsel --clipboard > decrypted.txt fi # Only works with bash (and not sh): echo "" echo "" echo "" read -s -n 1 -p "Press any key to continue…" |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | #!/bin/bash # Signieren von Text. # Erforderliche Linux-Pakete: gpg, xsel echo "Clipboard-Inhalt vor Signierung:" echo "********************************" echo "" xsel --clipboard echo "" echo "" echo "" echo "Mit GnuPG signieren ...:" echo "************************" echo "" xsel --clipboard | gpg2 --clearsign --detach-sign -a | xsel --clipboard echo "" echo "" echo "" echo "Clipboard-Inhalt nach Signierung:" echo "*********************************" echo "" xsel --clipboard echo "" echo "" echo "" echo "Signatur prüfen ...:" echo "************************" echo "" xsel --clipboard | gpg2 --verify -a | xsel --clipboard # Only works with bash (and not sh): echo "" echo "" echo "" read -s -n 1 -p "Press any key to continue…" |
Im Verschlüsselungsskript muss natürlich "meine@email.de" durch die E-Mail-Adresse des eigenen Schlüssels ersetzt werden. Am Ende des Skriptes wird der aktuelle Inhalt der Zwischenablage angezeigt, welcher wiederum mit Strg + V verwendet werden kann. Notwendige Pakete[2]: gpg und xsel
Links¶
Intern¶
Hintergrundinformationen zur Funktionsweise von GnuPG-Verschlüsselung
GPG-Agent - Passwortverwaltung für GnuPG
GNU Privacy Assistant - Grafische Oberfläche
KGpg - Grafische Oberfläche für KDE
Daten verschlüsseln Übersichtsartikel
Extern¶
GnuPG User Guides 🇬🇧 - u.a. auch deutsche Anleitungen, z.B.:
GNU-Handbuch zum Schutze der Privatsphäre 🇩🇪 – als HTML
GNU-Handbuch zum Schutze der Privatsphäre 🇩🇪 – als PDF
GnuPG Mini Howto 🇩🇪 - Mini-Howto
Privacy-Handbuch 🇩🇪 - auch im PDF-Format
German Privacy Foundation 🇩🇪 - ist mittlerweile aufgelöst
Der GNU Privacy Guard 🇩🇪 - Pro-Linux 02/2005
Das GNU Privacy Projekt (GnuPP) 🇩🇪 - inzwischen veraltete Seite, die aber die Grundlagen gut erklärt
GnuPP für Durchblicker 🇩🇪 ⮷ - ältere Informationen des Bundesministeriums für Wirtschaft und Technologie im PDF-Format
GnuPG für Windows 🇩🇪 - mit Handbuch
GnuPG Teil 0x1: Erzeugung eines Schlüsselpaares 🇩🇪 - Blogbeitrag, 01/2014
E-Mail Selbstverteidigung 🇩🇪 - Kampagne der Free Software Foundation (FSF)