Benutzer-Werkzeuge

Webseiten-Werkzeuge


anleitungen:gnupg_im_terminal

GnuPG im Terminal

1. Grundinstallation

In den meisten Linux-Distributionen ist gpg bereits enthalten. Sollte dies nicht der Fall sein, lässt es sich meist über den distributionseigenen Paketmanager installieren.

Ubuntu/Debian: # apt-get install gnupg

Arch: # pacman -Sy gnupg

2. Erstellen von PGP-Keys

Um einen Key im Terminal zu erstellen muss man

~ gpg --gen-key

eingeben. Unter ArchLinux ist die Option –full-gen-key zu verwenden.

Es erscheint folgende Anzeige:

gpg (GnuPG) 1.4.18; Copyright (C) 2014 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

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?

Wir geben hier 1 ein, da die Voreinstellung unseren Wünschen entspricht. Nachfolgend werden wir nach der Schlüssellänge gefragt (je länger desto besser/sicherer); wir geben also 4096 ein (es kann natürlich auch ein kürzerer Schlüssel verwendet werden. Von der Länge des Schlüssels hängt sowohl die Sicherheit als auch die Dauer der Erstellung ab!)

RSA-Schlüssel können zwischen 1024 und 4096 Bit lang sein.
Welche Schlüssellänge wünschen Sie? (2048) 4096

Anschließend wählen wir die Gültigkeitsdauer des Schlüssels, hier empfehle ich einen Schlüssel nicht unendlich lange gültig zu machen, sondern nach Ablauf einen neuen zu erstellen oder kurz davor zu verlängern. Ein praktikabler Wert sind meiner Meinung nach 2 Jahre, weshalb wir 2y eingeben. Nachdem man nochmals das Verfallsdatum bestätigt hat, geht es weiter.

Die verlangte Schlüssellänge beträgt 4096 Bit
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) 2y
Key verfällt am So 27 Nov 2016 18:52:31 CET
Ist dies richtig? (j/N) j

Nun müssen wir eingeben, wem der Schlüssel gehört. Die hier eingegebene E-Mail-Adresse muss die Adresse sein, welche zum Versenden und Empfangen signierter oder verschlüsselter Nachrichten dienen soll. (Es ist später auch möglich weitere E-Mail-Adressen hinzuzufügen, Link zu Tipps! FIXME)

Wir benötigen eine User-ID, um unseren Schlüssel eindeutig zu machen; das Programm baut diese User-ID aus unserem Namen, einem Kommentar und unserer Email-Adresse in dieser Form auf: „Maxi Muster (Der Mustermann) <maxi_at_muster.de>“

Ihr Name ("Vorname Nachname"): Max Muster 
Email-Adresse: 
Kommentar: 
Sie haben diese User-ID gewählt:
    "<Vorname Nachname Email-Adresse>"

Falls wir etwas ändern wollen haben wir nun noch die Möglichkeit es zu korrigieren ansonsten geht es mit einem F weiter und man soll ein Passwort für den Schlüssel festlegen, dieses Passwort wird beim versenden von eigenen oder aber beim lesen von E-Mails gebraucht (also bloß nicht vergessen und ein Sicheres Passwort wählen!)

Ändern: (N)ame, (K)ommentar, (E)-Mail oder (F)ertig/(B)eenden? f
Sie benötigen eine Passphrase, um den geheimen Schlüssel zu schützen.

Nachdem wir unser Passwort nun 2 mal eingegeben haben, möchte das Programm nun zufällige Eingaben des Systems registrieren um den Key zu erstellen, nun also einfach mal ein bisschen Browsen, Spielen, Programmieren oder etwas anderes machen damit der Schlüssel generiert werden kann. Je größer die Schlüssellänge anfangs gewählt wurde desto länger und desto mehr Eingaben braucht der Prozess um den Schlüssel zu erstellen! Es kann also durchaus mehrere Minuten dauern bis der Schlüssel erstellt ist!

3. Export des eigenen Keys

Um den Key auf einen Keyserver zu laden

Das Exportieren geht relativ leicht wir müssen lediglich erstmal unseren Schlüssel identifizieren

~ gpg --list-keys

als Ausgabe erhält man soetwas:

%%--------------------------------%%
pub   3072R/23D33FE7 2014-11-24 [verfällt: 2015-12-31]
uid                  Max Muster <max at must.er>
sub   3072R/A64EAF6A 2014-11-24 [verfällt: 2015-12-31]

Um die Anzeige kurz zu erläutern:

pub: public-teil des Keys
uid: zu dem Key gehörende E-Mail-Adressen
sub: privater-teil des Keys

3072R/23D33FE7 die 3072R zeigt an, dass hier der Schlüssel eine 3072-Bit-Länge hat und RSA verschlüsselt ist (bei 4096 steht hier entsprechend 4096R) hinter dem / befindet sich die Schlüssel-ID welche für uns interessant ist und wir im weiteren Verlauf noch öfters brauchen. Folgend bekommt man nur noch angezeigt, wann der Key erstellt wurde und wann dieser ungültig wird.

Nun kommen wir endlich zum Export auf unseren Key-Server:

~ gpg --keyserver keys.6502.me --send-keys <Schlüssel-ID>

und fertig! Der Schlüssel ist nun zum ersten Mal auf dem Key-Server.

Um den Key als Datei zu erhalten

Den Key benötigen wir als Datei, damit andere den Key als „vertrauenswürdig“ verifizieren können (dazu später mehr).

~ gpg -a --output dein-key.asc --export <optional Schlüssel-ID oder Name>

Der Schlüssel kann nun per E-Mail an andere verschickt werden. Es ist aber auch möglich, ihn auf einen Webspace zu laden, um seinen Public-Key einfach zu teilen.

4. Import von PGP-Keys

Von einem Server

Um den Key von einem Server zu Empfangen sollten wir zunächst herausfinden, ob der Key überhaupt auf dem Server existiert.

~ gpg --keyserver keys.6502.me --search-keys <Name oder falls bekannt die ID>

Alternativ kann man sich aber auch einfach alle Schlüssel mit

~ gpg --keyserver keys.6502.me --list-keys

anzeigen lassen.

Als Name reicht es aus, die E-Mail-Adresse anzugeben oder aber nur einen Teil dieser. Selbstverständlich funktioniert auch einfach Mustermann, wenn man nach dem Key zu Max Mustermann suchen möchte.

Da wir nun wissen, dass der Key auf dem Server vorhanden ist, können wir ihn nun importieren. Wer möchte kann auch optional −−with-fingerprints angeben, um zu überprüfen, ob der richtige Schlüssel heruntergelanden wird dies funktioniert nur über die Schlüssel-ID.

~ gpg --keyserver keys.6502.me --recv-keys <Schlüssel-ID>

Aus einer Datei

Der Befehl sollte am einfachsten im Ordner ausgeführt werden, in dem die Datei liegt.

Wer möchte kann natürlich zuvor den Fingerprint überprüfen:

~ gpg --with-fingerprint /tmp/dateiname.asc

Und dieser Befehl importiert nun den Key:

~ gpg --import /tmp/dateiname.asc

5. Vertrauen/Signierung eines PGP-Keys

Vertrauen

Die Vertrauensstufe legt fest, inwieweit wir der Person hinter dem Key vertrauen.

Wir gehen dabei davon aus, dass der Key bereits eingefügt ist, welcher signiert werden soll. Mittels folgendem Befehl kommen wir in den Bearbeitungsmodus für den Schlüssel:

~ gpg --edit-key <Key-ID oder Name>

anschließend bekommen wir eine Eingabeaufforderung von gpg, in der wir

trust

eingeben müssen. Anschließend erhalten wir Auswahlmöglichkeiten, um die Vertrauensstufe festzulegen.

Bitte entscheiden Sie, in wieweit Sie diesem User zutrauen,
Schlüssel anderer User korrekt zu prüfen (durch Vergleich
mit Lichtbildausweisen, Vergleich der Fingerabdrücke aus
unterschiedlichen Quellen ...)?


 1 = Weiß nicht so recht
 2 = Nein, ihm traue ich NICHT
 3 = Ich vertraue ihm marginal
 4 = Ich vertraue ihm vollständig
 5 = Ich vertraue ihm absolut
 m = Zurück zum Menü

Ihre Auswahl?

Damit die Auswahloptionen etwas verständlicher werden, empfehle ich das ubuntuusers-Wiki. Als Einstellungen kommen vor allem Optionen 3 oder 4 in Betracht. Bei Option 3 werden von dem Besitzer signierte Schlüssel nicht automatisch als gültig/vertrauenswürdig erachtet, bei Option 4 hingegen schon.

Um dem gpg-Prompt wieder zu verlassen geben wir nun

quit

ein.

Signierung

Die Signierung des Keys ist hingegen wieder sehr einfach:

~ gpg --sign-key <keyname>

und schon sind wir fertig.

Wer jedoch lieber mit dem gpg-Promt arbeitet, kann dies natürlich tun, der entsprechende Befehl dazu lautet:

sign

und erfordert im Anschluss noch einmal eine Sicherheitsbestätigung und das eigene Passwort, um den Schlüssel zu signieren.

Damit nun auch andere Wissen, dass wir dem Schlüssel vertrauen, sollten wir ihn wieder auf den Keyserver hochladen oder aber ihn wieder als Datei zurück zum Besitzer schicken, damit er dies tut. Wie das geht ist ja bereits bekannt. Weiterführende Informationen, vor allem über den Hintergund der Signierung, findet man in der Wikipedia.

anleitungen/gnupg_im_terminal.txt · Zuletzt geändert: 2018/08/03 01:11 von stephanvoeth