Benutzer-Werkzeuge

Webseiten-Werkzeuge


tachtler:gnupg

GnuPG

GnuPG ist eine komplett freie Implementierung des GNU Projekts OpenPGP welches den Standard wie im RFC4880 definiert, umsetzt.

Mit einem durch GnuPG generiertem Schlüsselpaar eröffnen sich eine Reihe von Anwendungsgebiete, wie z.B.:

  • das Erstellen einer digitalen Signatur
  • das verschlüssel, entschlüssel und überprüfen von Daten, welche nicht für die Allgemeinheit bestimmt sind
  • hinzufügen von weiteren Identitäten zu einem Schlüssel (zusätzliche e-Mail-Adressen)
  • beglaubigen der eigenen oder weiteren Identitäten

Installation

Ab hier werden root-Rechte zur Ausführung der nachfolgenden Befehle benötigt. Um root zu werden geben Sie bitte folgenden Befehl ein:

$ su -
Password: 

:!: HINWEIS - Meist ist das Paket, welches aus den CentOS-Repository's (CentOS-Base) stammt, bereits installiert!

Mit nachfolgenden Befehl werden die notwendigen Komponenten aus den Standard-Repository's von CentOS - base installiert:

# yum install gnupgp
...

ab CentOS Version 6.x

# yum install pinentry-gtk
...

Schlüsselgenerierung

Nach abgeschlossener GnuPG-Installtion, kann der erste Schlüssel erzeugt werden!

Solange jedoch mit Schlüssel experimentiert wird und nicht sicher ist, ob der/die so generierten Schlüssel auch tatsächlich verwendet werden sollen, empfiehlt es sich nicht, die so generierten Schlüssel auf einen „Keyserver“ hochzuladen.

:!: WICHTIG - Befindet sich ein Schlüssel erst einmal auf einem „Keyserver“, kann er von dort nicht mehr entfernt werden und wird ebenfalls auf andere „Keyserver“ verteilt.

Ein bereits auf einem „Keyserver“ befindlicher Schlüssel kann nur noch zurückgezogen werden. Hier wird diesem öffentlichen Schlüssel eine Anmerkung angeheftet, dass er ungültig ist und nicht mehr verwendet werden kann!

Primäre User-ID

Ein neu erzeugter Schlüssel bekommt zunächst eine primäre User-ID (primary uid). Diese kann z.B. aus folgenden Angaben bestehen:

  • Namen
  • e-Mail-Adresse
  • Kommentar

Mit diesen Angaben wird der Schlüssel einer Person zugeordnet!

:!: WICHTIG - Nachträgliche Änderungen an den hier verwendeten Daten haben zur folge, dass evtl. Beglaubigungen der damit generierten Schlüssel ungültig werden und wegfallen, deshalb sollte nur eine e-Mail-Adresse verwendet werden, wenn diese auch dauerhaft verwendet werden kann!

:!: HINWEIS - Alternativen zur Angabe einer e-Mail-Adresse könnte das Geburtsdatum und der Geburtsort im Kommentarfeld sein und dafür keine Angabe der e-Mail-Adresse.

:!: BITTE ENTSCHEIDEN SIE SELBST !

Befehl zur Generierung: CentOS 5

Mit nachfolgendem Befehl, kann ein Schlüsselpaar generiert werden:

# gpg --gen-key
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.

Please select what kind of key you want:
   (1) DSA and Elgamal (default)
   (2) DSA (sign only)
   (5) RSA (sign only)
Your selection? 1
DSA keypair will have 1024 bits.
ELG-E keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
    "Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"

Real name: Klaus Tachtler
Email address: klaus@tachtler.net
Comment: root
You selected this USER-ID:
    "Klaus Tachtler (root) <klaus@tachtler.net>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
You need a Passphrase to protect your secret key.

Enter passphrase:
Repeat passphrase:

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
++++++++++..+++++++++++++++++++++++++.++++++++++++++++++++.+++++++++++++++++++++++++.+++++.+++++++++++++++++++++++++.+++++++++++++++++++++++++......+++++

Not enough random bytes available.  Please do some other work to give
the OS a chance to collect more entropy! (Need 283 more bytes)
We need to generate a lot of random bytes. It is a good idea to perform                                                    
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
+++++.++++++++++++++++++++.++++++++++++++++++++...++++++++++.+++++.++++++++++...++++++++++.+++++...++++++++++.+++++++++++++++.+++++.+++++.++++++++++.++++
++++++++++++++++++++++++++.+++++>+++++...+++++.+++++.++++++++++.....+++++++++++++++.+++++.+++++>+++++>..+++++.>+++++.....................................
........................>+++++...................<..+++++............................+++++^^^

  1. Die Angabe der Option 1 bewirkt, dass der DSA zum signieren und ElGamal als asymmetrischer Chiffrierung zum Einsatz kommt
  2. Die Angabe der Schlüssellänge 4096 ist das Maximum. Wobei auch 2048 noch ausreichend wäre
  3. Die Angabe der Gültigkeit 0 lässt den Schlüssel nie ablaufen
  4. Die Angebe der unbegrenzten Gültigkeit mit 0 muss explicit noch einmal mit y bestätigt werden!
  5. Es folgt der reale Name - Klaus Tachtler
  6. Es folgt die e-Mail-Adresse - klaus@tachtler.net
  7. Es folgt ein Kommentar - root - (nur als Beispiel)
  8. Die Angaben werden mit O (großgeschrieben) bestätigt
  9. Die zweimalige Angabe der Passphrase sollte mit einem nicht zu kurzem Kennwort beantwortet werden…
  10. Jetzt sollten mit Maus und Tastatur, oder anderen Aktionen - Zufallszahlen generieren…

Am Ende gibt GnuPG die Schlüssel-ID des neuen Schlüssel aus:

gpg: /root/.gnupg/trustdb.gpg: trustdb created
gpg: key 96CB52B7 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   1024D/96CB52B7 2009-06-03
      Key fingerprint = AE89 DDDA 3F13 867C 5BED  C0C8 0EBA 2C34 96CB 52B7
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

:!: HINWEIS - Nachfolgend einige Erklärungen zur Ausgabe der Schlüssel-ID des neuen Schlüssel:

Folgende Zeile bezeichnet den 1024 Bit langen DSA-Schlüssel, welcher auch der „Hauptschlüssel“ genannt wird

pub   1024D/96CB52B7 2009-06-03
Folgende Zeile bezeichnet den Fingerabdruck (fingerprint)
      Key fingerprint = AE89 DDDA 3F13 867C 5BED  C0C8 0EBA 2C34 96CB 52B7
Folgende Zeile bezeichnet den verwendete primäre ID (primary uid)
uid                  Klaus Tachtler (root) <root@tachtler.net>
Abschließend folgt dann der Unterschlüssel (subkey) mit der ID F347C5BA, ein 4096 Bit langer ElGamal-Schlüssel, welcher zur Ver- und Entschlüsselung verwendet wird
sub   4096g/F347C5BA 2009-06-03

:!: HINWEIS - Ein solcher ElGamail Encryption Key darf nicht mit einem ElGamil sign+encrypt key verwechselt werden. Letzterer bekommt als Kennung statt dem kleinen g ein großes G nach der Längenangabe - hier 4096 - und ist kompromitierbar und darf nicht mehr verwendet werden!

Die Schlüssel befinden sich jetzt im HOME-Verzeichnis des Benutzer unter dem die Schlüssel generiert wurden - hier z.B. /root/.gnupg - wessen Inhalt mit nachfolgendem Befehl angezeigt werden kann:

# ls -la /root/.gnupg/
total 52
drwx------  2 root root 4096 Jun  3 14:23 .
drwxr-x--- 38 root root 4096 Jun  3 13:55 ..
-rw-------  1 root root 9207 Dec 18 11:54 gpg.conf
-rw-------  1 root root 4724 Jun  3 14:23 pubring.gpg
-rw-------  1 root root 4724 Jun  3 14:23 pubring.gpg~
-rw-------  1 root root  600 Jun  3 14:23 random_seed
-rw-------  1 root root 1849 Jun  3 14:23 secring.gpg
-rw-------  1 root root 1280 Jun  3 14:23 trustdb.gpg

Befehl zur Generierung: CentOS 6

Ab CentOS Version 6.x:

Mit nachfolgendem Befehl, kann ein Schlüsselpaar generiert werden:

$ gpg --gen-key
gpg (GnuPG) 2.0.14; Copyright (C) 2009 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.

gpg: directory `/home/klaus/.gnupg' created
gpg: new configuration file `/home/klaus/.gnupg/gpg.conf' created
gpg: WARNING: options in `/home/klaus/.gnupg/gpg.conf' are not yet active during this run
gpg: keyring `/home/klaus/.gnupg/secring.gpg' created
gpg: keyring `/home/klaus/.gnupg/pubring.gpg' created
Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

GnuPG needs to construct a user ID to identify your key.

Real name: Klaus Tachtler
Email address: klaus@tachtler.net
Comment: klaus
You selected this USER-ID:
    "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
You need a Passphrase to protect your secret key.

can't connect to `/home/klaus/.gnupg/S.gpg-agent': No such file or directory
gpg-agent[5001]: directory `/home/klaus/.gnupg/private-keys-v1.d' created
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

sgdgsdggsdfgjslkdjfögsdfnabdbfasdf a/sdfgsdfgsdfgsdfg780q9phwrkcbvyx
apshfdöq6 adfh 0adtfasdf7328u4bdliat9d fq3öt zfg98sd9guhak gh7 ztpqi
uhaifdvaszfaisuhdfa7sdt f4gif astdzfoagsd f76as0 7dpsuf ßa6dazfhiuah
q76r065 zprhasödhhjads7fa9s6d7fb4534765asdf7hasfd7as8fhkj434652793zh
 a pfahfnasm,vdnhUSUOZ G UZTS(F8d7fhsaiödfh padzt7f8 G /&FDSGDSGS DI
S&D PZ PSHDI7sfaiihuiua7df z3 z4phaisudfas fasgasfgasgasgasdfas98 as
d7 fzasdf 0asdpfu SUZSTDZUTS D6sdfsddfzds6dfasfzasdf786a086tc465028v
05fcb856df20835zTOUZTSUFZTD F&F(/&E/P EZ ?§ U)& Pzf8 a876f08a szdf78
6as 7f804r9283246 8 68 86fasd f6807as fazr876zfgasihfasd764z32 7560z
zdf7asdf7a807d6f a08s76 fd6f 6346538 fasfasdf sda7fas6dfa4sdf654a8s7
d f3245 237ßu alsdfjü

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.

fsügdbßs9b+sdfbs#fksad §$$%SDdssidfs7d8fzs8dsdfkgsdgskädfg#+sdfpogsdf
g w a87fßa sd7füa0s4 w34u sau ügasfgsdfgsdf sdf gsdfgsdfgs dg9 3ß957
76af6312519 0 % )%§$=§/& ?§/§ 77 8a7sdfa7sßdf7ß7 443´ 85´09f7sßdf6as
7d6fß943´5 87üfsdJSDFHGSfsdfsaas7dfaszfasdf7s7 dfß98as7df73 73ß4 947
 ß987f76sdf6a0s dfz087asf087asdf asdzf8/&/S&D / SD(&=6087465834608 7
 t3497 77 876sdzfgasfh pisauf diafzaß9 uffshgzetaps vcvyxvcvnbas,mfh
a höerw faskjd asduf aiosdf iasdfoisdufasjdflkasjdfoiasudfjdsaklfjad
ifasdjf ldfj adfaü+sadfoas3 4u47 dfaddfadfd7sdfgsßdfg7sdf g9üwoi56 ü
9uüosudf gsdf7 gsdfgsdf gsdf7g97ß6734´65 budf8sfgs ädfjäd#fg+++gd 74
 tz47857f708gsdf 6g76347(&$&%$&S%)& ==(/ sdf 0s76g ß9ß54 75 78fd7gß9
sdßf g7sd98f gsdfg s

gpg: /home/klaus/.gnupg/trustdb.gpg: trustdb created
gpg: key C67F36D0 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   4096R/C67F36D0 2013-09-22
      Key fingerprint = 9DB2 F4EE A084 A92B ED0D  D455 2BD2 59DD C67F 36D0
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/5E4A2AAD 2013-09-22

1. Die Angabe der Option 1 bewirkt, dass der RSA zum signieren und RSA als asymmetrischer Chiffrierung zum Einsatz kommt
2. Die Angabe der Schlüssellänge 4096 ist das Maximum. Wobei auch 2048 noch ausreichend wäre
3. Die Angabe der Gültigkeit 0 lässt den Schlüssel nie ablaufen
4. Die Angebe der unbegrenzten Gültigkeit mit 0 muss explicit noch einmal mit y bestätigt werden!
5. Es folgt der reale Name - Klaus Tachtler
6. Es folgt die e-Mail-Adresse - klaus@tachtler.net
7. Es folgt ein Kommentar - klaus - (nur als Beispiel)
8. Die Angaben werden mit O (großgeschrieben) bestätigt
9. Die zweimalige Angabe der Passphrase sollte mit einem nicht zu kurzem Kennwort beantwortet werden…

Es erscheint nachfolgendes Eingabefenster

Pinentry

Und zur Bestätigung der „Passphrase“ nochmals nachfolgendes Eingabefenster.

Pnentry re-entry

10. Jetzt sollten mit Maus und Tastatur, oder anderen Aktionen - Zufallszahlen generieren…

Am Ende gibt GnuPG die Schlüssel-ID des neuen Schlüssel aus:

gpg: /home/klaus/.gnupg/trustdb.gpg: trustdb created
gpg: key C67F36D0 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   4096R/C67F36D0 2013-09-22
      Key fingerprint = 9DB2 F4EE A084 A92B ED0D  D455 2BD2 59DD C67F 36D0
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/5E4A2AAD 2013-09-22

:!: HINWEIS - Nachfolgend einige Erklärungen zur Ausgabe der Schlüssel-ID des neuen Schlüssel:

Folgende Zeile bezeichnet den 4096 Bit langen RSA-Schlüssel, welcher auch der „Hauptschlüssel“ genannt wird

pub   4096R/C67F36D0 2013-09-22
Folgende Zeile bezeichnet den Fingerabdruck (fingerprint)
      Key fingerprint = 9DB2 F4EE A084 A92B ED0D  D455 2BD2 59DD C67F 36D0
Folgende Zeile bezeichnet den verwendete primäre ID (primary uid)
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
Abschließend folgt dann der Unterschlüssel (subkey) mit der ID 5E4A2AAD, ein 4096 Bit langer RSA-Schlüssel, welcher zur Ver- und Entschlüsselung verwendet wird
sub   4096R/5E4A2AAD 2013-09-22

Die Schlüssel befinden sich jetzt im HOME-Verzeichnis des Benutzer unter dem die Schlüssel generiert wurden - hier z.B. /klaus/.gnupg - wessen Inhalt mit nachfolgendem Befehl angezeigt werden kann:

$ ls -la ~/.gnupg/
total 44
drwx------   3 klaus klaus 4096 Sep 22 22:39 .
drwx------. 27 klaus klaus 4096 Sep 22 22:29 ..
-rw-------   1 klaus klaus 7856 Sep 22 22:29 gpg.conf
drwx------   2 klaus klaus 4096 Sep 22 22:29 private-keys-v1.d
-rw-------   1 klaus klaus 2226 Sep 22 22:39 pubring.gpg
-rw-------   1 klaus klaus 2226 Sep 22 22:39 pubring.gpg~
-rw-------   1 klaus klaus  600 Sep 22 22:39 random_seed
-rw-------   1 klaus klaus 4884 Sep 22 22:39 secring.gpg
-rw-------   1 klaus klaus 1280 Sep 22 22:39 trustdb.gpg

Befehl zur Generierung: CentOS 7

Ab CentOS Version 7.x:

Bevor mit der Generierung begonnen werden kann, sollte um die spätere Eingabe eines Passwortes in einer grafischen Eingabe durchführen zu können, zuerst nachfolgende Umgebungsvariable gesetzte werden, was mit nachfolgendem Befehl durchgeführt werden kann:

# export PINENTRY_BINARY="/usr/bin/pinentry-curses"

Ob die Umgebungsvariable korrekt gesetzt wurde, kann mit nachfolgendem Befehl überprüft werden:

# echo $PINENTRY_BINARY
/usr/bin/pinentry-curses

:!: HINWEIS - Dies bewirkt, das auch in Umgebungen in denen keine X-Server, oder in denen nur eine ssh-Verbindung besteht, ebenfalls die Eingabe und Verifizierung eines Passwortes für die Passphrase, durchgeführt werden kann!

Mit nachfolgendem Befehl, kann ein Schlüsselpaar generiert werden:

$ gpg --gen-key
gpg (GnuPG) 2.0.22; Copyright (C) 2013 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.

gpg: directory `/home/klaus/.gnupg' created
gpg: new configuration file `/home/klaus/.gnupg/gpg.conf' created
gpg: WARNING: options in `/home/klaus/.gnupg/gpg.conf' are not yet active during this run
gpg: keyring `/home/klaus/.gnupg/secring.gpg' created
gpg: keyring `/home/klaus/.gnupg/pubring.gpg' created
Please select what kind of key you want:
   (1) RSA and RSA (default)
   (2) DSA and Elgamal
   (3) DSA (sign only)
   (4) RSA (sign only)
Your selection? 1
RSA keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048) 4096
Requested keysize is 4096 bits
Please specify how long the key should be valid.
         0 = key does not expire
      <n>  = key expires in n days
      <n>w = key expires in n weeks
      <n>m = key expires in n months
      <n>y = key expires in n years
Key is valid for? (0) 0
Key does not expire at all
Is this correct? (y/N) y

GnuPG needs to construct a user ID to identify your key.

Real name: Klaus Tachtler
Email address: klaus@tachtler.net
Comment: klaus
You selected this USER-ID:
    "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O
You need a Passphrase to protect your secret key.

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
gpg: /home/klaus/.gnupg/trustdb.gpg: trustdb created
gpg: key EDB9DA12 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   4096R/EDB9DA12 2014-09-27
      Key fingerprint = 7ABD C6A1 8EB1 AAE4 A2AC  CC31 DF40 E5EC EDB9 DA12
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/1683B321 2014-09-27

1. Die Angabe der Option 1 bewirkt, dass der RSA zum signieren und RSA als asymmetrischer Chiffrierung zum Einsatz kommt
2. Die Angabe der Schlüssellänge 4096 ist das Maximum. Wobei auch 2048 noch ausreichend wäre
3. Die Angabe der Gültigkeit 0 lässt den Schlüssel nie ablaufen
4. Die Angebe der unbegrenzten Gültigkeit mit 0 muss explicit noch einmal mit y bestätigt werden!
5. Es folgt der reale Name - Klaus Tachtler
6. Es folgt die e-Mail-Adresse - klaus@tachtler.net
7. Es folgt ein Kommentar - klaus - (nur als Beispiel)
8. Die Angaben werden mit O (großgeschrieben) bestätigt
9. Die zweimalige Angabe der Passphrase sollte mit einem nicht zu kurzem Kennwort beantwortet werden…

Es erscheint nachfolgendes Eingabefenster

            ┌─────────────────────────────────────────────────────┐
            │ Enter passphrase                                    │
            │                                                     │
            │                                                     │
            │ Passphrase ________________________________________ │
            │                                                     │
            │       <OK>                             <Cancel>     │
            └─────────────────────────────────────────────────────┘

Und zur Bestätigung der „Passphrase“ nochmals nachfolgendes Eingabefenster.

            ┌─────────────────────────────────────────────────────┐
            │ Please re-enter this passphrase                     │
            │                                                     │
            │ Passphrase ________________________________________ │
            │                                                     │
            │       <OK>                             <Cancel>     │
            └─────────────────────────────────────────────────────┘

10. :!: HINWEIS - Um mehr „Entropien“ zur Beschleunigung der Generierung des GPG-Schlüssels zur Verfügung zu haben, kann die Erzeugung der Zufallszahlen durch das Starten von Systemaktivitäten positiv beeinflusst werden. Nachfolgender Befehl, in einer zweiten shell auf dem selben Rechner aufgerufen, kopiert dazu den Inhalt einer Festplatte, hier /dev/sda nach /dev/null (Null Device).

# dd if=/dev/vda of=/dev/null
20480000+0 records in
20480000+0 records out
10485760000 bytes (10 GB) copied, 53.8159 s, 195 MB/s

Am Ende gibt GnuPG die Schlüssel-ID des neuen Schlüssel aus:

We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
We need to generate a lot of random bytes. It is a good idea to perform
some other action (type on the keyboard, move the mouse, utilize the
disks) during the prime generation; this gives the random number
generator a better chance to gain enough entropy.
gpg: /home/klaus/.gnupg/trustdb.gpg: trustdb created
gpg: key EDB9DA12 marked as ultimately trusted
public and secret key created and signed.

gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
pub   4096R/EDB9DA12 2014-09-27
      Key fingerprint = 7ABD C6A1 8EB1 AAE4 A2AC  CC31 DF40 E5EC EDB9 DA12
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/1683B321 2014-09-27

:!: HINWEIS - Nachfolgend einige Erklärungen zur Ausgabe der Schlüssel-ID des neuen Schlüssel:

Folgende Zeile bezeichnet den 4096 Bit langen RSA-Schlüssel, welcher auch der „Hauptschlüssel“ genannt wird

pub   4096R/EDB9DA12 2014-09-27
Folgende Zeile bezeichnet den Fingerabdruck (fingerprint)
      Key fingerprint = 7ABD C6A1 8EB1 AAE4 A2AC  CC31 DF40 E5EC EDB9 DA12
Folgende Zeile bezeichnet den verwendete primäre ID (primary uid)
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
Abschließend folgt dann der Unterschlüssel (subkey) mit der ID 1683B321, ein 4096 Bit langer RSA-Schlüssel, welcher zur Ver- und Entschlüsselung verwendet wird
sub   4096R/1683B321 2014-09-27

Die Schlüssel befinden sich jetzt im HOME-Verzeichnis des Benutzer unter dem die Schlüssel generiert wurden - hier z.B. /klaus/.gnupg - wessen Inhalt mit nachfolgendem Befehl angezeigt werden kann:

$ ll -la ~/.gnupg/
total 36
drwx------  3 klaus klaus  154 Sep 27 06:47 .
drwx------. 4 klaus klaus 4096 Sep 27 06:42 ..
-rw-------  1 klaus klaus 7680 Sep 27 06:42 gpg.conf
drwx------  2 klaus klaus    6 Sep 27 06:44 private-keys-v1.d
-rw-------  1 klaus klaus 2227 Sep 27 06:47 pubring.gpg
-rw-------  1 klaus klaus 2227 Sep 27 06:47 pubring.gpg~
-rw-------  1 klaus klaus  600 Sep 27 06:47 random_seed
-rw-------  1 klaus klaus 4885 Sep 27 06:47 secring.gpg
srwxrwxr-x  1 klaus klaus    0 Sep 27 06:46 S.gpg-agent
-rw-------  1 klaus klaus 1280 Sep 27 06:47 trustdb.gpg

Schlüsselpaar

Ein frisch erzeugtes Schlüsselpaar besteht aus

  • einem privaten Teil-Schlüssel (private key) und
  • einem öffentlichen Teil-Schlüssel (public key)

:!: WICHTIG - Wer Zugang zum prtivaten Teil-Schlüssel hat, kann Identitätsdiebstahl begehen! - Mit dem privaten Teil-Schlüssel signierte Dateien, fallen auf den eigentlichen Schlüsselbesitzer zurück! - Missbrauch durch Dritte wäre möglich!

Schlüsseldateien

Die Schlüsseldateien liegen nach der frischen Generierung standardmäßig im HOME-Verzeichnis des jeweiligen Benutzer, der die Schlüsselpaar-Generierung ausgeführt hat - z.B.

  • /root/.gnupg/ oder
  • /home/klaus/.gnupg/

:!: WICHTIG - Alle Dateien im Verzeichnis ~/.gnupg, sollten daher folgende Dateirechte haben:

Z.B. - für den Benutzer root, was mit nachfolgendem Befehl überprüft werden kann:

# ll -la
total 52
drwx------  2 root root 4096 Jun  3 14:23 .
drwxr-x--- 38 root root 4096 Jun  3 15:12 ..
-rw-------  1 root root 9207 Dec 18 11:54 gpg.conf
-rw-------  1 root root 4724 Jun  3 14:23 pubring.gpg
-rw-------  1 root root 4724 Jun  3 14:23 pubring.gpg~
-rw-------  1 root root  600 Jun  3 14:23 random_seed
-rw-------  1 root root 1849 Jun  3 14:23 secring.gpg
-rw-------  1 root root 1280 Jun  3 14:23 trustdb.gp

Falls dies NICHT so sein sollte, kann mit nachfolgenden Befehlen dies erreicht werden, zuerst die Besitzrechte - hier root - und anschließend die Dateirechte:

# chown root.root ~/.gnupg/*
und
# chmod 600 ~/.gnupg/*

Schlüsselring: secring.gpg

Im HOME-Verzeichnis des entsprechenden Benutzers - hier root - befindet sich der Schlüsselring

  • /root/.gnupg/secring.gpg

in dem sich

  • der oder die privaten Schlüssel befinden!

Mit nachfolgendem Befehl kann der Inhalt ausgegeben werden:

# gpg --list-secret-keys
/root/.gnupg/secring.gpg
------------------------
sec   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
ssb   4096g/F347C5BA 2009-06-03

Schlüsselring: pubring.gpg

Im HOME-Verzeichnis des entsprechenden Benutzers - hier root - befindet sich der Schlüsselring

  • /root/.gnupg/pubring.gpg

in dem sich

  • der oder die eigenen öffentlichen Schlüssel und
  • die öffentlichen Schlüssel von anderen befinden!

Mit nachfolgendem Befehl kann der Inhalt ausgegeben werden:

# gpg --list-keys
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

Mit nachfolgendem Befehl können die enthaltenen Signaturen ausgegeben werden:

# gpg --list-sigs
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sig 3        96CB52B7 2009-06-03  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03
sig          96CB52B7 2009-06-03  Klaus Tachtler (root) <root@tachtler.net>

Die Ausgabe der Signaturen besagt, dass

  • sowohl der „Hauptschlüssel“ - (1024D/96CB52B7)
  • als auch der Unterschlüssel (subkey) - (4096g/F347C5BA)

von Klaus Tachtler selbst, und zwar

  • mit dem privaten Schlüssel - (96CB52B7)

beglaubigt wurden, wie die Zeilen mit den sig voran zeigen!

Rückrufzertifikat

Das Rückrufzertifikat (revocation certificate) sollte gleich nach der Erstellung des Schlüsselpaares erstellt werden, da es dazu dient, falls aus irgendwelchen Gründen das Schlüsselpaar bzw. der private Schlüssel nicht mehr als vertrauenswürdig erscheinen sollte, dieser mittels des Rückrufzertifikat (revocation certificate) als nicht mehr zu verwenden gekennzeichnet werden kann.

Um ein solches Rückrufzertifikat (revocation certificate) zu erstellen sind allerdings

  • der private Schlüssel und
  • die Passphrase des privaten Schlüssels

notwendig.

:!: HINWEIS - Falls der private Schlüssel oder die Passphrase des privaten Schlüssels NICHT mehr zur Verfügung stehen sollte, kann auch ein Rückrufzertifikat (revocation certificate) NICHT mehr erstellt werden!

Mit Hilfe des Rückrufzertifikat (revocation certificate) wird dann der Schlüssel als zurückgezogen markiert und lädt Ihn dann auf einen „Keyserver“.

:!: HINWEIS - Für den Rückruf des Schlüssel wird dann nur noch der öffentliche Schlüssel benötigt!

Befehl zur Generierung: CentOS 5

Zuerst werden mit folgender Befehl die öffentlichen Schlüssel aus dem pubring.gpg aufgelistet:

# gpg --list-keys
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

Nachfolgender Befehl generiert dann ein sogenanntes Rückrufzertifikat (revocation certificate) für den „Hauptschlüssel“:

# gpg --gen-revoke 96CB52B7

sec  1024D/96CB52B7 2009-06-03 Klaus Tachtler (root) <root@tachtler.net>

Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? 3
Enter an optional description; end it with an empty line:
>
Reason for revocation: Key is no longer used
(No description given)
Is this okay? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

Enter passphrase: 

ASCII armored output forced.
Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The print system of
your machine might store the data and make it available to others!
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: A revocation certificate should follow

iZkAIBECBAkRAkomi3ACHTMZCgkWDrssNJbOUr0q0QCePBjsfYNLi/RSFykdMy2g
Ykegj1wAn1SHaQW0qyZ16edhQhih3f+NyoWq
=wA0A
-----END PGP PUBLIC KEY BLOCK-----

  1. Die Generierung muss explicit noch einmal mit y bestätigt werden!
  2. Als Grund des Rückzugs wird hier 3 gewählt
  3. Eine optionale Beschriebung zum Grund, kann angegeben werden oder mit [Enter]-Taste auch leer gelassen werden
  4. Abschließend müssen explicit noch einmal die Anagben mit y bestätigt werden!
  5. Dann erfolgt die Einageb der Passphrase

:!: WICHTIG - Folgender Absatz stellt das Rückrufzertifikat (revocation certificate) dar und MUSS nun noch in eine Datei kopiert werden UND möglichst sicher aufbewahrt werden!

:!: BEISPIEL - Der Name der Datei mit dem Rückrufzertifikat (revocation certificate) könnte z.B. /tmp/revoke.txt lauten!

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: A revocation certificate should follow

iZkAIBECBAkRAkomi3ACHTMZCgkWDrssNJbOUr0q0QCePBjsfYNLi/RSFykdMy2g
Ykegj1wAn1SHaQW0qyZ16edhQhih3f+NyoWq
=wA0A
-----END PGP PUBLIC KEY BLOCK-----

Befehl zur Generierung: CentOS 6

Ab CentOS Version 6.x

Zuerst werden mit folgender Befehl die öffentlichen Schlüssel aus dem pubring.gpg aufgelistet:

$ gpg --list-keys
/home/klaus/.gnupg/pubring.gpg
------------------------------
pub   4096R/C67F36D0 2013-09-22
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/5E4A2AAD 2013-09-22

Nachfolgender Befehl generiert dann ein sogenanntes Rückrufzertifikat (revocation certificate) für den „Hauptschlüssel“:

$ gpg --gen-revoke C67F36D0

sec  4096R/C67F36D0 2013-09-22 Klaus Tachtler (klaus) <klaus@tachtler.net>

Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? 3
Enter an optional description; end it with an empty line:
> 
Reason for revocation: Key is no longer used
(No description given)
Is this okay? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
4096-bit RSA key, ID C67F36D0, created 2013-09-22

can't connect to `/home/klaus/.gnupg/S.gpg-agent': No such file or directory
ASCII armored output forced.

An dieser Stelle erscheint nun nachfolgendes Eingabefenster

Pinentry - Revoke

Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The print system of
your machine might store the data and make it available to others!
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.14 (GNU/Linux)
Comment: A revocation certificate should follow

iQIfBDFTZHHDMIJSP1syAh0DAAoJECvSWd3GfzbQ6E4P/3R3C54Kpe8h4VZq0d5q
OaHBWqQMYP2h1pQAYfAW9RlQfQPTpyzxvhYrDCwLno6Yx9PMGk+6swfxKHqewj5i
NMGctAGX3EREvOe8UpEWLknwy7i6wJi8siXWUS7PStPh4tLAsH5pyv3PRAOdBN4R
qPHhdA0jL+iofZFINrmvFi5VkKJJzzdfsz6hgzueH3F+I+cQCf/dXpJ2fuyvAy5C
66Ysqje0VwBG15ljfs+GGTFORXjyC30LRLjwhW1b0lShUGGTVxpn5Rc51ZqBwJ1/
CE2AFdKGc8xgQLRMGStogmqGjdr1nz4MZFhQ5Bp1wQLCQKMKYZ3jzO0/3pCNlR6/
E7fjBuWDzqWZk+2q4xzu7sdfjkhd7fsdu4cZiXwSDrsXlEHGDzExnbtjBE6R0YGR
DLxuhuG4WU97v+bhFTSqm2QmvoBaOts4rRVrCvMGdma/SoPOPzWThBbVeNL/dJQQ
iHkAtAQw7QFsrajxQV788miA3M1lS4bPg+9PmBs5pB4FDage0IiCTcPmRSxxdAcR
ItM3uHL23eaK2ASQMjWMIXVXt80GJvXNSNQJfmhVMFo2ngpYkn23IXi7GM9YDmOJ
bIRe+eT0LRgbRztkw0of3XuUPAoJhjszz6qtwgh30jklc2UMvRFsD8eN6pY60hi+
vYa1X0GSAUohFjH5BAKHWL5F
=ccVb
-----END PGP PUBLIC KEY BLOCK-----

  1. Die Generierung muss explicit noch einmal mit y bestätigt werden!
  2. Als Grund des Rückzugs wird hier 3 gewählt
  3. Eine optionale Beschriebung zum Grund, kann angegeben werden oder mit [Enter]-Taste auch leer gelassen werden
  4. Abschließend müssen explicit noch einmal die Anagben mit y bestätigt werden!
  5. Dann erfolgt die Einageb der Passphrase

:!: WICHTIG - Folgender Absatz stellt das Rückrufzertifikat (revocation certificate) dar und MUSS nun noch in eine Datei kopiert werden UND möglichst sicher aufbewahrt werden!

:!: BEISPIEL - Der Name der Datei mit dem Rückrufzertifikat (revocation certificate) könnte z.B. /tmp/revoke.txt lauten!

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.14 (GNU/Linux)
Comment: A revocation certificate should follow

iQIfBDFTZHHDMIJSP1syAh0DAAoJECvSWd3GfzbQ6E4P/3R3C54Kpe8h4VZq0d5q
OaHBWqQMYP2h1pQAYfAW9RlQfQPTpyzxvhYrDCwLno6Yx9PMGk+6swfxKHqewj5i
NMGctAGX3EREvOe8UpEWLknwy7i6wJi8siXWUS7PStPh4tLAsH5pyv3PRAOdBN4R
qPHhdA0jL+iofZFINrmvFi5VkKJJzzdfsz6hgzueH3F+I+cQCf/dXpJ2fuyvAy5C
66Ysqje0VwBG15ljfs+GGTFORXjyC30LRLjwhW1b0lShUGGTVxpn5Rc51ZqBwJ1/
CE2AFdKGc8xgQLRMGStogmqGjdr1nz4MZFhQ5Bp1wQLCQKMKYZ3jzO0/3pCNlR6/
E7fjBuWDzqWZk+2q4xzu7sdfjkhd7fsdu4cZiXwSDrsXlEHGDzExnbtjBE6R0YGR
DLxuhuG4WU97v+bhFTSqm2QmvoBaOts4rRVrCvMGdma/SoPOPzWThBbVeNL/dJQQ
iHkAtAQw7QFsrajxQV788miA3M1lS4bPg+9PmBs5pB4FDage0IiCTcPmRSxxdAcR
ItM3uHL23eaK2ASQMjWMIXVXt80GJvXNSNQJfmhVMFo2ngpYkn23IXi7GM9YDmOJ
bIRe+eT0LRgbRztkw0of3XuUPAoJhjszz6qtwgh30jklc2UMvRFsD8eN6pY60hi+
vYa1X0GSAUohFjH5BAKHWL5F
=ccVb
-----END PGP PUBLIC KEY BLOCK-----

Befehl zur Generierung: CentOS 7

Ab CentOS Version 7.x

Zuerst werden mit folgender Befehl die öffentlichen Schlüssel aus dem pubring.gpg aufgelistet:

$ gpg --list-keys
/home/klaus/.gnupg/pubring.gpg
------------------------------
pub   4096R/EDB9DA12 2014-09-27
uid                  Klaus Tachtler (klaus) <klaus@tachtler.net>
sub   4096R/1683B321 2014-09-27

Nachfolgender Befehl generiert dann ein sogenanntes Rückrufzertifikat (revocation certificate) für den „Hauptschlüssel“:

$ gpg --gen-revoke EDB9DA12

sec  4096R/EDB9DA12 2014-09-27 Klaus Tachtler (klaus) <klaus@tachtler.net>

Create a revocation certificate for this key? (y/N) y
Please select the reason for the revocation:
  0 = No reason specified
  1 = Key has been compromised
  2 = Key is superseded
  3 = Key is no longer used
  Q = Cancel
(Probably you want to select 1 here)
Your decision? 3
Enter an optional description; end it with an empty line:
>
Reason for revocation: Key is no longer used
(No description given)
Is this okay? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
4096-bit RSA key, ID EDB9DA12, created 2014-09-27

ASCII armored output forced.

An dieser Stelle erscheint nun nachfolgendes Eingabefenster

   ┌───────────────────────────────────────────────────────────────────────┐
   │ Please enter the passphrase to unlock the secret key for the OpenPGP  │
   │ certificate:                                                          │
   │ "Klaus Tachtler (klaus) <klaus@tachtler.net>"                         │
   │ 4096-bit RSA key, ID EDB9DA12,                                        │
   │ created 2014-09-27.                                                   │
   │                                                                       │
   │                                                                       │
   │ Passphrase __________________________________________________________ │
   │                                                                       │
   │          <OK>                                         <Cancel>        │
   └───────────────────────────────────────────────────────────────────────┘

Revocation certificate created.

Please move it to a medium which you can hide away; if Mallory gets
access to this certificate he can use it to make your key unusable.
It is smart to print this certificate and store it away, just in case
your media become unreadable.  But have some caution:  The print system of
your machine might store the data and make it available to others!
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.22 (GNU/Linux)
Comment: A revocation certificate should follow

iQIfBCABAgAJBQJUJkfYAh0DAAoJEN9A5eztudoSyc4P/0BdMlkcWG9u9zHN9e2C
wOLvvae8m0HZld0hJRaFFhIAqe+3SiYKH2kcHrUk19hh4rLr3WaRprULm5K7Ji2e
hZCgRG+tCJ97EBcHA0k85ePpdwG+j9/zMeaSx4x2CCOg6qBaHXINlczKSBxpJ6ir
AFC2zCoqjShv1AiQAY74oIGgOGVF1rXvR4hQvjv7l9Pjlpa86kEADmt5BZAPWjDv
HsDufqTpgLJtZ5eAqVLkbfDr2hIwKaTGJSYpJEMfY3Z7PMeZtiOBIZtzbTEeVakP
o5VTkKOdASc6yPmXS3Y4DkabvHfA//trppTZJ/qrVmO8BW9nzT8fHZFPK96vI9HP
SHWGP6ALKehyzvrtiWLdsgBxBZtu0O4C011LVJMfDr7oVpKpY6nQT2bLvCJktyO9
ywMHfjGCyZ4xrzmNHwilAPpXnSoynGcyPR4BocL58SxGjQt3LwQ2lx7Qp8sSHyv/
JO79oECON7rgybZQkz6bGDmwpXrHAA6udMgD/Fp3E7ELK6LEI+c4CNqNa3uszp9a
2T3/0Me4T+5uKjL7hCC7Kmxa8C+5Cbolp5D7rWigOn5Z4ItrIGy0wDkRVu2vMZg7
gwIG7nlKAZ/cWaMWm30j6XIVS5FcI6g+a7zrGHlB5JCMrYL+E1Wy12s2OBfF1X5X
7UbnwHT8E2c4O4zyJpPAqVRA
=5OLf
-----END PGP PUBLIC KEY BLOCK-----

  1. Die Generierung muss explizit noch einmal mit y bestätigt werden!
  2. Als Grund des Rückzugs wird hier 3 gewählt
  3. Eine optionale Beschreibung zum Grund, kann angegeben werden oder mit [Enter]-Taste auch leer gelassen werden
  4. Abschließend müssen explizit noch einmal die Angaben mit y bestätigt werden!
  5. Dann erfolgt die Eingabe der Passphrase

:!: WICHTIG - Folgender Absatz stellt das Rückrufzertifikat (revocation certificate) dar und MUSS nun noch in eine Datei kopiert werden UND möglichst sicher aufbewahrt werden!

:!: BEISPIEL - Der Name der Datei mit dem Rückrufzertifikat (revocation certificate) könnte z.B. /tmp/revoke.txt lauten!

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.22 (GNU/Linux)
Comment: A revocation certificate should follow

iQIfBCABAgAJBQJUJkfYAh0DAAoJEN9A5eztudoSyc4P/0BdMlkcWG9u9zHN9e2C
wOLvvae8m0HZld0hJRaFFhIAqe+3SiYKH2kcHrUk19hh4rLr3WaRprULm5K7Ji2e
hZCgRG+tCJ97EBcHA0k85ePpdwG+j9/zMeaSx4x2CCOg6qBaHXINlczKSBxpJ6ir
AFC2zCoqjShv1AiQAY74oIGgOGVF1rXvR4hQvjv7l9Pjlpa86kEADmt5BZAPWjDv
HsDufqTpgLJtZ5eAqVLkbfDr2hIwKaTGJSYpJEMfY3Z7PMeZtiOBIZtzbTEeVakP
o5VTkKOdASc6yPmXS3Y4DkabvHfA//trppTZJ/qrVmO8BW9nzT8fHZFPK96vI9HP
SHWGP6ALKehyzvrtiWLdsgBxBZtu0O4C011LVJMfDr7oVpKpY6nQT2bLvCJktyO9
ywMHfjGCyZ4xrzmNHwilAPpXnSoynGcyPR4BocL58SxGjQt3LwQ2lx7Qp8sSHyv/
JO79oECON7rgybZQkz6bGDmwpXrHAA6udMgD/Fp3E7ELK6LEI+c4CNqNa3uszp9a
2T3/0Me4T+5uKjL7hCC7Kmxa8C+5Cbolp5D7rWigOn5Z4ItrIGy0wDkRVu2vMZg7
gwIG7nlKAZ/cWaMWm30j6XIVS5FcI6g+a7zrGHlB5JCMrYL+E1Wy12s2OBfF1X5X
7UbnwHT8E2c4O4zyJpPAqVRA
=5OLf
-----END PGP PUBLIC KEY BLOCK-----

Schlüssel zurückrufen

Soll ein Schlüssel nun zurückgerufen werden, muss die Datei mit dem Rückrufzertifikat (revocation certificate) als Inhalt mit nachfolgendem Befehl in den öffentlichen Schlüsselbund - importiert werden:

# gpg --import /tmp/revoke.txt
gpg: key 96CB52B7: "Klaus Tachtler (root) <root@tachtler.net>" revocation certificate imported
gpg: Total number processed: 1
gpg:    new key revocations: 1
gpg: 3 marginal-needed, 1 complete-needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u

:!: VORSICHT - GnuPG erkennt, dass es sich um ein Rückrufzertifikat (revocation certificate) für einen bestimmten Schlüssel handelt UND hängt diesen UNWIDERRUFLICH an! - Es erfolgt KEINE Sicherheitsabfrage!

Mit nachfolgendem Befehl können die enthaltenen Signaturen - inklusive des Rückrufzertifikats (revocation certificate) - ausgegeben werden:

# gpg --list-sigs
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
rev          96CB52B7 2009-06-03  Klaus Tachtler (root) <root@tachtler.net>
uid                  Klaus Tachtler (root) <root@tachtler.net>
sig 3        96CB52B7 2009-06-03  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03
sig          96CB52B7 2009-06-03  Klaus Tachtler (root) <root@tachtler.net>

:!: WICHTIG - Abschließend wird dann der zurückgezogene Schlüssel wieder auf einen Keyserver geladen!

Schlüsseleditor

Ein Schlüssel besitzt Eigenschaften die evtl. von Zeit zu Zeit verändern werden müssen, dazu kann der Schlüsseleditor genutzt werden. Desweiteren kann mit dem Schlüsseleditor ein öffentlicher Schlüssel - signiert werden!

Der Schlüsseleditor kann in der shell unter Angabe einer Schlüsselidentifikationsnummer (key ID) oder eines anderen, im Schlüsselring eindeutig enthaltenen Merkmals (z.B. einer user ID) aufgerufen werden.

# gpg --edit-key root
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.

Secret key is available.

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1). Klaus Tachtler (root) <root@tachtler.net>

Command> help

:!: HINWEIS - Bei der Ausgabe ist eine Besonderheit zu erwähnen, die Zeile Secret key is available. besagt, dass zu dieem öffentlichen Schlüssel auch ein privater Schlüssel vorhanden ist!

Folgende Kommandos zur Manipulation des Schlüssels können eingegeben werden:

quit        quit this menu
save        save and quit
help        show this help
fpr         show key fingerprint
list        list key and user IDs
uid         select user ID N
key         select subkey N
check       check signatures
sign        sign selected user IDs [* see below for related commands]
lsign       sign selected user IDs locally
tsign       sign selected user IDs with a trust signature
nrsign      sign selected user IDs with a non-revocable signature
adduid      add a user ID
addphoto    add a photo ID
deluid      delete selected user IDs
addkey      add a subkey
addcardkey  add a key to a smartcard
keytocard   move a key to a smartcard
bkuptocard  move a backup key to a smartcard
delkey      delete selected subkeys
addrevoker  add a revocation key
delsig      delete signatures from the selected user IDs
expire      change the expiration date for the key or selected subkeys
primary     flag the selected user ID as primary
toggle      toggle between the secret and public key listings
pref        list preferences (expert)
showpref    list preferences (verbose)
setpref     set preference list for the selected user IDs
keyserver   set the preferred keyserver URL for the selected user IDs
notation    set a notation for the selected user IDs
passwd      change the passphrase
trust       change the ownertrust
revsig      revoke signatures on the selected user IDs
revuid      revoke selected user IDs
revkey      revoke key or selected subkeys
enable      enable key
disable     disable key
showphoto   show selected photo IDs
clean       compact unusable user IDs and remove unusable signatures from key
minimize    compact unusable user IDs and remove all signatures from key

Schlüssel editieren

User ID hinzufügen: adduid

Als Beispiel soll dem nachfolgend aufgelisteten Schlüssel eine weitere user ID hinzugefügt werden. Zuerst wird der aktuelle öffentliche Schlüsselring aufgelistet:

# gpg --list-keys
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

Zuerst wird der Schlüsseleditor mit nachfolgendem Befehl gestartet:

# gpg --edit-key 96CB52B7
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.

Secret key is available.

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1). Klaus Tachtler (root) <root@tachtler.net>

Command>

Jetzt wird eine weitere user ID mit nachfolgendem Befehl, welcher nach Command> eingegeben wird, hinzugefügt:

Command> adduid
Real name: Klaus Tachtler
Email address: hostmaster@tachtler.net
Comment: hostmaster
You selected this USER-ID:
    "Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>"

Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? O

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

                  
pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1)  Klaus Tachtler (root) <root@tachtler.net>
[ unknown] (2). Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>

Command>

:!: HINWEIS - Die primäre user ID ist in der Anzeige mit einem . (Punkt) nach der Nummer gekennzeichnet!

Um die primäre user ID zu wechseln, kann folgender Befehl eingegeben werden:

Command> uid 1

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1)* Klaus Tachtler (root) <root@tachtler.net>
[ unknown] (2). Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>

Command> primary

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

                  
pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1)* Klaus Tachtler (root) <root@tachtler.net>
[ unknown] (2)  Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>

Command> 

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

User ID löschen: deluid

:!: WICHTIG - Eine user ID kann nur solange gelöscht werden, solange der Schlüssel noch NICHT auf einem Keyserver veröffentlicht wurde! - Nach einer Veröffentlichung auf einem KeyServer kann ein Schlüssel nur noch zurückgezogen werden!.

Zuerst wird der Schlüsseleditor mit nachfolgendem Befehl gestartet:

# gpg --edit-key 96CB52B7
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.

Secret key is available.

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1). Klaus Tachtler (root) <root@tachtler.net>
[ultimate] (2)  Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>

Command>

:!: WICHTIG - Anschließend muss die zu bearbeitende user ID ausgewählt werden, was mit nachfolgendem Befehl durchgeführt werden kann:

Command> uid 2

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1). Klaus Tachtler (root) <root@tachtler.net>
[ultimate] (2)* Klaus Tachtler (hostmaster) <hostmaster@tachtler.net>

Command>

* Die zu bearbeitende user ID ist mit einem * (Stern) markiert

Jetzt wird die markierte user ID mit nachfolgendem Befehl, welcher nach Command> eingegeben wird, gelöscht:

Command> deluid
Really remove this user ID? (y/N) y

pub  1024D/96CB52B7  created: 2009-06-03  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096g/F347C5BA  created: 2009-06-03  expires: never       usage: E   
[ultimate] (1). Klaus Tachtler (root) <root@tachtler.net>

Command>

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

Exportieren des öffentlichen Schlüssels

Um den eigenen öffentlichen Schlüssel zu veröffentlichen, wird dies in aller Regel direkt aus dem Schlüsselbund auf einen Keyserver hoch geladen werden.

Export in eine Datei

Der öffentlichen Schlüssel kann auch in eine Datei exportiert werden, was mit nachfolgendem Befehl durchgeführt werden kann:

# gpg --export 96CB52B7 > root.bin 

Der Inhalt der Datei ist in binärer Schreibweise, wie nachfolgende Ausgabe mit folgendem Befehl zeigt:

# cat root.bin 
��J&jG�sw&7���8Ճ���8�1�<���6��ǭo����p.��$)��I���Z���*l�o�yޟk��=%ֶ:*�SJ)�       �Ξ)������;;SA%����/L��|� ž:ÊUŸ⎽≤┌ÙXÐ⎺  ì:®ÍÇÑ&⎽¥¶B⎽Ä;¡
·\ÌMþ:YD␋/äþ7ø X¦=?G␋X=SÒ>␊¡º†ŸH␌Ç°ÏB×π┴‹ùÎñ*”ð┼Ç>Õ¶␊,¢íª.Íñ™└
                                                             =åá┼Xæ‡L␍─ɓ┘†à±V¿─P¶âÖ4ƒ%─¹$5,‹³ÝÖ\ÜÖÙ:‡>_&
                                                                                                                ØÓ (ù°Å▒‘ûç['˜’┴)´ T•J‰žñ▒ÐÅ
ÉÞ0ِ!†Ñ©≥·M€ã≥.½ÞþÀî€öï¨⎺„ú±
                   šºàÙÜ<-�2�eXdX��d���
                                         ���<#�"�����)������
`+nE����S�]��)Klaus Tachtler (root) <root@tachtler.net>�c#
                                                                       �J'~�
J&┐= ‡2âçÆ ⎼]¥¼≤°Ñ␋┐½÷Ò)Ì:£X─AMSÊÈ_âóã‚2¨Ȑ&�N����+�`��-*+]÷¢⎽‡Ä«Ô£¾ÎáA‹&š$=YXæ[␊èÂ#┌ÇQ¾ðÇ‘]Þ⎺›íN#*▒HCôÇìVÄ␊Íÿ¤¡E      π┘éE]]ŒŒý÷ð³
@+�O)�.$M��ܑ������ }{�6���79'�@�L�=��v�k�ǟlۚK�0���L
���RN��                                      n��r-�5���w9�2��3"��HQpYʤ8�)&���!��69u��..����>d��Ljp_�
         ��$�&|��?��Q&>�c7֊1*q�$�޹f�C"��sJ��ʲ���XJJ��դ;
                                                              )��Pv9(n�hP
                                                                          �
䣒°º␌Þ┼I┤°Æ;±ö2©¹Øé⎺ȟѝ§“ÖàP       ·P¯é¡#Ö£4ÌÞ?ˆ)O ²¾’Ì>⎼Ýû<˜üD␍„)*┤␍œπH�Q[&xπ‘␊õMºî·
┬ì1)GÖU±ÿ┘␋?Â#X3ã@[·» �X�\I~���Kx@��<Vm��$�͖%��1��v��]m˷��2�>����0�Q0VĀ����]��������
                                                                                                3��]C�i�c�b��g�.mK�[^a������w;����)>
���
P┬*DIÔöçÜT@Óí�Hž≤Ã␊‘M[Ô:Ÿ¡$^©└°._#Ö¿”ãR뗡�^���b�#���l��Ҧ┌ôE%俉ñ
í¬£˜6
       ,–.¢·»(“J;¸3^ëß¿ö$’≠ZÆÚ˜≠T
™3¥ñGùQE&W¾!HƧË÷є›Œ├ޘä‚^≠¤8ƒ°”XªÄŠJ9I≤NŸ—âö·âó"^î°«ƒÁ–Ð4°⎼┌
                                
                                 îIC4¾—ÀTÉV!áϦABC’␤ä5ˆXY¨ÐÖ·┐9°┘Âá^
_ì¬¨G„¼┐'6Ø⎺─$ 1�2�8��挼�`��� 6`�s��������������~�+�K��)���m�<L����I     J&k=

        º,4–ËR·G· Ÿ␊éQ°Ë␉9±πªC┘E!ZäÈ  ¡¥à┐3��iNlc�^5�d*

:!: HINWEIS - Diese Art des Exports ist eher unüblich!

Der öffentlichen Schlüssel kann auch im ASCII-Format in eine Datei exportiert werden, was mit nachfolgendem Befehl durchgeführt werden kann:

# gpg --export --armor 96CB52B7 > root.asc

Der Inhalt der Datei ist im ASCII-Format, wie nachfolgende Ausgabe mit folgendem Befehl zeigt:

# cat root.asc 
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.5 (GNU/Linux)
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=am1m
-----END PGP PUBLIC KEY BLOCK-----

Export auf einen Keyserver

Der öffentlichen Schlüssel kann mit nachfolgendem Befehl auf einen Keyserver exportiert werden:

# gpg --keyserver sks.gpg-keyserver.de --send-key 96CB52B7
gpg: sending key 96CB52B7 to hkp server sks.gpg-keyserver.de

Der Schlüssel kann auch manuell durch kopieren in ein Web-Formular eines Keyservers exportiert werden, hier z.B. auf:

Statt immer manuell den Keyserver einzutragen, kann dieser auch in der jeweiligen Konfigurationsdatei von GnuPG im jeweiligen HOME-Verzeichnis des jeweiligen Benutzers eingetragen werden. Dies kann wie folgt erfolgen - hier am Beispiel der Konfigurationsdatei ~/.gnupg/gpg.conf (nur relevnater Ausschnitt)):

...
# GnuPG can send and receive keys to and from a keyserver.  These
# servers can be HKP, email, or LDAP (if GnuPG is built with LDAP
# support).
#
# Example HKP keyserver:
#      hkp://subkeys.pgp.net
#
# Example email keyserver:
#      mailto:pgp-public-keys@keys.pgp.net
#
# Example LDAP keyservers:
#      ldap://keyserver.pgp.com
#
# Regular URL syntax applies, and you can set an alternate port
# through the usual method:
#      hkp://keyserver.example.net:22742
#
# If you have problems connecting to a HKP server through a buggy http
# proxy, you can use keyserver option broken-http-proxy (see below),
# but first you should make sure that you have read the man page
# regarding proxies (keyserver option honor-http-proxy)
#
# Most users just set the name and type of their preferred keyserver.
# Note that most servers (with the notable exception of
# ldap://keyserver.pgp.com) synchronize changes with each other.  Note
# also that a single server name may actually point to multiple
# servers via DNS round-robin.  hkp://subkeys.pgp.net is an example of
# such a "server", which spreads the load over a number of physical
# servers.


# Tachtler
# default: keyserver hkp://subkeys.pgp.net
keyserver hkp://sks.gpg-keyserver.de
#keyserver mailto:pgp-public-keys@keys.nl.pgp.net
#keyserver ldap://keyserver.pgp.com

...

Exportieren des privaten Schlüssels

Zu Sicherungszwecken, oder auch zur Einbindung in andere Programme z.B. e-Mail-Software, kann auch ein privater Schlüssel exportiert werden!

Export in eine Datei

Der private Schlüssel kann auch in eine Datei exportiert werden, was mit nachfolgendem Befehl durchgeführt werden kann:

# gpg --export-secret-keys 96CB52B7 > secroot.bin 

:!: * Der Inhalt der Datei ist in binärer Schreibweise

Der private Schlüssel kann auch im ASCII-Format in eine Datei exportiert werden, was mit nachfolgendem Befehl durchgeführt werden kann:

# gpg --export-secret-keys --armor 96CB52B7 > secroot.asc

:!: * Der Inhalt der Datei ist im ASCII-Format

Es besteht auch die Möglichkeit den privaten Schlüssel mit einem symmetrischen Verfahren verschlüsselt zu exportieren. Mit nachfolgendem Befehl kann überprüft werden, welche Verfahren die Version von GnuPG bietet:

# gpg --version
gpg (GnuPG) 1.4.5
Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.

Home: ~/.gnupg
Supported algorithms:
Pubkey: RSA, RSA-E, RSA-S, ELG-E, DSA
Cipher: 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH
Hash: MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Ein Beispiel für einen Export des privaten Schlüssel mit einem symmetrischen Verfahren verschlüsselt zu exportieren, dies unter Verwendung des AES-Verfahrens mit einer Schlüssellänge von 256, würde der Befehl wie folgt lauten:

# gpg --armor --export-secret-keys 96CB52B7 | gpg --armor --symmetric --cipher-algo AES256 > seckey_AES256.gpg
Enter passphrase:
Repeat passphrase:

:!: * Die hier gewählte passphrase muss nicht mit der des privaten Schlüssels übereinstimmen

Der Inhalt der Datei hier seckey_AES256.gpg würde dann wie folgt aussehen (nur beispielhafter Ausschnitt)):

# cat seckey_AES256.gpg 
-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.5 (GNU/Linux)

jA0ECQMCwJIEEYwXFXtg0usB/2+NGRHhjdztD$dkdHHJ78dkKGD6f7hHDF/FHj/f
rT55KqQO1vEJta9UGjFddKdOVlewtNDgSuooE68nTESNJ+fPvug+tSkmvivynG6L
...
...
rhHfURkbYw+31538eU3kR7PfEA==
=0vHA
-----END PGP MESSAGE-----

Importieren von öffentlichen Schlüsseln

Um Daten, und damit auch e-Mails und deren Anhänge, so zu verschlüsseln, dass

  • nur der Empfänger sie mit seinem privaten Schlüssel lesen kann
  • oder um die Herkunft und Unversehrtheit einer Datei oder Nachricht zu überprüfen

wird der passende öffentliche Schlüssel dieser Person im eigenen Schlüsselbund benötigt.

Nur so können e-Mails, deren Anhänge oder Dateien die von einer anderen Person mit dessen privaten Schlüssel verschlüsselt wurden, wieder von uns selbst entschlüsselt werden!

Zum Import eines öffentlichen Schlüssels einer anderen Person wird entweder

  • eine Datei mit dem öffentlichen Schlüssels der anderen Person welche von dieser erzeugt wurde ODER
  • die Informationen liegen auf einem Keyserver, dazu wird der Name des Keyservers unbd die Schlüssel-ID benötigt

Import aus einer Datei

Zum Import aus einer Datei, kann nachfolgender Befehl verwendet werden - die Datei mit dem öffentlichen Schlüssel liegt hier unter /tmp/michi.asc:

# gpg --import /tmp/michi.asc 
gpg: key 2384C849: public key "Michael Nausch <michael@nausch.org>" imported
gpg: Total number processed: 1
gpg:               imported: 1

Eine Auflistung mit nachfolgendem Befehl, würde nach dem Import wie folgt aussehen:

# gpg --list-keys
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

pub   1024D/2384C849 2009-03-30
uid                  Michael Nausch <michael@nausch.org>
uid                  Michael Nausch (aka BigChief) <bigchief@omni128.de>
uid                  Michael Nausch (aka Django) <django@nausch.org>
sub   4096g/D239B202 2009-03-30

Import von einem Keyserver

Zum Import von einem Keyserver, kann nachfolgender Befehl verwendet werden - der öffentlichen Schlüssel liegt hier auf dem Keyserver - sks.gpg-keyserver.de:

# gpg --keyserver hkp://sks.gpg-keyserver.de --recv-key 2384C849
gpg: requesting key 2384C849 from hkp server sks.gpg-keyserver.de
gpg: key 2384C849: public key "Michael Nausch <michael@nausch.org>" imported
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: Total number processed: 1
gpg:               imported: 1

Eine Auflistung mit nachfolgendem Befehl, würde nach dem Import wie folgt aussehen:

# gpg --list-keys
/root/.gnupg/pubring.gpg
------------------------
pub   1024D/96CB52B7 2009-06-03
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

pub   1024D/2384C849 2009-03-30
uid                  Michael Nausch <michael@nausch.org>
uid                  Michael Nausch (aka Django) <django@nausch.org>
uid                  Michael Nausch (aka BigChief) <bigchief@omni128.de>
sub   4096g/D239B202 2009-03-30

Vertrauenssatus festlegen

Beim Import von öffentlichen Schlüsseln von dritten Personen sind noch zwei wichtige Punkte zu klären:

  1. Stammt der Schlüssel tatsächlich von der Person, welche behauptet der Besitzer zu sein
  2. Ist der Urheber des Schlüssel vertrauenswürdig, auch im Umgang mit Schlüsseln

Fingerprint

Mit dem nachfolgendem Befehl, kann ein sogenannter Fingerprint eines Schlüssels erzeugt werden, um diesen besser vergleichen zu können:

# gpg --fingerprint 96CB52B7
pub   1024D/96CB52B7 2009-06-03
      Key fingerprint = AE89 DDDA 3F13 867C 5BED  C0C8 0EBA 2C34 96CB 52B7
uid                  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/F347C5BA 2009-06-03

Beispielsweise konnte der Fingerprint am Telefon, oder persönlich ausgetauscht werden, wozu sich jetzt der gesamte öffentliche Schlüssel kaum eignet!

Vertrausstatus speichern

Falls die beiden Punkte

  1. Stammt der Schlüssel tatsächlich von der Person, welche behauptet der Besitzer zu sein
  2. Ist der Urheber des Schlüssel vertrauenswürdig, auch im Umgang mit Schlüsseln

erfolgreich geklärt sind, kann einem im öffentlichen Schlüsselring befindlichen öffentlichen Schlüssel einer dritten Person das Vertrauen ausgesprochen werden.

Dazu ist der Aufruf des Schlüsseleditors mit nachfolgendem Befehl notwendig:

# gpg --edit-key 2384C849
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.


pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: unknown       validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> trust
pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: unknown       validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I don't know or won't say
  2 = I do NOT trust
  3 = I trust marginally
  4 = I trust fully
  5 = I trust ultimately
  m = back to the main menu

Your decision? 4

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>
Please note that the shown key validity is not necessarily correct
unless you restart the program.

Command>quit

Folgende Vertrauensstufen stehen zur Auswahl an:

  • 1 = I don't know or won't say (q)
  • 2 = I do NOT trust (n)
  • 3 = I trust marginally (m)
  • 4 = I trust fully (f)
  • 5 = I trust ultimately (u)

:!: HINWEIS - Wobei das Vertrauen gegenüber einem dritten maxmimal 4 = I trust fully ausgesprochen werden sollte!

Schlüssel beglaubigen

Eine weitere Vertrauensstufe ist das signieren aller öffentlicher Schlüssel und der user ID einer dritten Person.

Es ist durchaus empfehlenswert und auch Praxis auf sogenannten Key-Signing-Partys Einsicht in amtliche Dokumente, wie

  • Reisepass
  • Personalausweis
  • oder ggf. auch Führerschein

zu nehmen um die Identität welche in der user ID angegeben ist zu verifizieren.

Falls alle Zweifel an einer tatsächlich richtigen user ID ausgeräumt sind, kann mit nachfolgendem Befehl die öffentlicher Schlüssel und die user ID einer dritten Person im eigenen öffentlicher Schlüsselring - signieren:

Einfache Beglaubigung

1. Möglichkeit (eine bestimmte user ID signieren):

gpg --edit-key 2384C849
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.


pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> uid 1

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1)* Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> sign

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
 Primary key fingerprint: 4947 6D9B 8199 EEC4 15A9  6915 1F04 71F1 2384 C849

     Michael Nausch <michael@nausch.org>

Are you sure that you want to sign this key with your
key "Klaus Tachtler (root) <root@tachtler.net>" (96CB52B7)

Really sign? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

Enter passphrase:    

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

2. Möglichkeit (alle - restlichen user ID's signieren):

# gpg --edit-key 2384C849
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.


gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   1  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: depth: 1  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 1f, 0u
pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: full
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[  full  ] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> sign
Really sign all user IDs? (y/N) y
"Michael Nausch <michael@nausch.org>" was already signed by key 96CB52B7

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: full
 Primary key fingerprint: 4947 6D9B 8199 EEC4 15A9  6915 1F04 71F1 2384 C849

     Michael Nausch (aka BigChief) <bigchief@omni128.de>
     Michael Nausch (aka Django) <django@nausch.org>

Are you sure that you want to sign this key with your
key "Klaus Tachtler (root) <root@tachtler.net>" (96CB52B7)

Really sign? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

Enter passphrase:

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

Nach erfolgreicher Signierung kann mit nachfolgendem Aufruf überprüft werden, ob alle user ID's korrekt signiert wurden:

# gpg --list-sigs 2384C849
gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   1  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: depth: 1  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 1f, 0u
pub   1024D/2384C849 2009-03-30
uid                  Michael Nausch <michael@nausch.org>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig          96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
uid                  Michael Nausch (aka Django) <django@nausch.org>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig          96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
uid                  Michael Nausch (aka BigChief) <bigchief@omni128.de>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig          96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/D239B202 2009-03-30
sig          2384C849 2009-03-30  Michael Nausch <michael@nausch.org>

Erweiterte Beglaubigung

1. Möglichkeit (eine bestimmte user ID signieren):

gpg --edit-key 2384C849
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.


pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> uid 1

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[ unknown] (1)* Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> tsign

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: unknown
 Primary key fingerprint: 4947 6D9B 8199 EEC4 15A9  6915 1F04 71F1 2384 C849

     Michael Nausch <michael@nausch.org>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I trust marginally
  2 = I trust fully

Your selection? 2

Please enter the depth of this trust signature.
A depth greater than 1 allows the key you are signing to make
trust signatures on your behalf.

Your selection? 3

Please enter a domain to restrict this signature, or enter for none.

Your selection? 

Are you sure that you want to sign this key with your
key "Klaus Tachtler (root) <root@tachtler.net>" (96CB52B7)

Really sign? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

Enter passphrase:

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

2. Möglichkeit (alle - restlichen user ID's signieren):

# gpg --edit-key 2384C849
gpg (GnuPG) 1.4.5; Copyright (C) 2006 Free Software Foundation, Inc.
This program comes with ABSOLUTELY NO WARRANTY.
This is free software, and you are welcome to redistribute it
under certain conditions. See the file COPYING for details.


gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   1  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: depth: 1  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 1f, 0u
pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: full
sub  4096g/D239B202  created: 2009-03-30  expires: never       usage: E   
[  full  ] (1). Michael Nausch <michael@nausch.org>
[ unknown] (2)  Michael Nausch (aka BigChief) <bigchief@omni128.de>
[ unknown] (3)  Michael Nausch (aka Django) <django@nausch.org>

Command> tsign
Really sign all user IDs? (y/N) y
"Michael Nausch <michael@nausch.org>" was already signed by key 96CB52B7

pub  1024D/2384C849  created: 2009-03-30  expires: never       usage: SC  
                     trust: full          validity: full
 Primary key fingerprint: 4947 6D9B 8199 EEC4 15A9  6915 1F04 71F1 2384 C849

     Michael Nausch (aka Django) <django@nausch.org>
     Michael Nausch (aka BigChief) <bigchief@omni128.de>

Please decide how far you trust this user to correctly verify other users' keys
(by looking at passports, checking fingerprints from different sources, etc.)

  1 = I trust marginally
  2 = I trust fully

Your selection? 2

Please enter the depth of this trust signature.
A depth greater than 1 allows the key you are signing to make
trust signatures on your behalf.

Your selection? 3

Please enter a domain to restrict this signature, or enter for none.

Your selection? 

Are you sure that you want to sign this key with your
key "Klaus Tachtler (root) <root@tachtler.net>" (96CB52B7)

Really sign? (y/N) y

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (root) <root@tachtler.net>"
1024-bit DSA key, ID 96CB52B7, created 2009-06-03

Enter passphrase:

:!: WICHTIG - Wenn alle Änderungen durchgeführt sind, müssen die Änderungen noch gespeichert werden!

Zum Speichern der Änderungen im Schlüsseleditor, wird nachfolgender Befehl eingegeben:

Command> save

:!: HINWEIS - Der Schlüsseleditor beendet sich, ohne Rückfrage!

Nach erfolgreicher Signierung kann mit nachfolgendem Aufruf überprüft werden, ob alle user ID's korrekt signiert wurden:

# gpg --list-sigs 2384C849
gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   1  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: depth: 1  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 1f, 0u
pub   1024D/2384C849 2009-03-30
uid                  Michael Nausch <michael@nausch.org>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig        3 96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
uid                  Michael Nausch (aka Django) <django@nausch.org>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig        3 96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
uid                  Michael Nausch (aka BigChief) <bigchief@omni128.de>
sig 3        2384C849 2009-03-30  Michael Nausch <michael@nausch.org>
sig        3 96CB52B7 2009-06-04  Klaus Tachtler (root) <root@tachtler.net>
sub   4096g/D239B202 2009-03-30
sig          2384C849 2009-03-30  Michael Nausch <michael@nausch.org>

Als Liste um einen Anhaltspunkt zu haben, was bei folgender Frage an Werten vergeben werden kann

Please enter the depth of this trust signature.
A depth greater than 1 allows the key you are signing to make
trust signatures on your behalf.

Your selection? 
soll diese Liste eine Orientierungshilfe sein:

  • (0) I will not answer.
  • (1) I have not checked at all.
  • (2) I have done casual checking.
  • (3) I have done very careful checking.

Austausch beglaubigter Schlüssel

Durch die Beglaubigung des öffentlichen Schlüssels von Michael Nausch michael@nausch.org und dessen user ID's hat sich sozusagen der öffentlichen Schlüssels von Michael Nausch michael@nausch.org verändert. Dieser veränderte öffentlichen Schlüssels von Michael Nausch michael@nausch.org sollte nun wieder in eine Datei exportiert werden und Michael Nausch michael@nausch.org z.B. via e-Mail zugestellt werden, damit dieser dann seinen jetzt erweiterten öffentlichen Schlüssels auf einen Keyserver hoch laden kann!

Der Export in eine Datei kann mit folgendem Befehl realisiert werden:

# gpg --export --armor 2384C849 > /tmp/michis_public_key_von_klaus_signiert.asc

Keyserver abfragen

Hier eine kleine Auswahl an Keyservern

Mit nachfolgendem Befehl, kann z.B. nach einem bestimmten Schlüssel auf einem Keyserver gesucht werden:

# gpg --keyserver hkp://sks.gpg-keyserver.de --search-keys Michael Nausch
gpg: searching for "Michael Nausch" from hkp server sks.gpg-keyserver.de
(1)     Michael Nausch <michael@nausch.org>
        Michael Nausch (aka Django) <django@nausch.org>
        Michael Nausch (aka BigChief) <bigchief@omni128.de>
          1024 bit DSA key 2384C849, created: 2009-03-30
(2)     Michael Nausch (aka Django, BigChief) <michael@nausch.org>
          1024 bit DSA key B3648FCD, created: 2009-03-29
(3)     Michael Nausch (aka Django, aka BigChief) <michael@nausch.org>
          1024 bit DSA key 940A0CFC, created: 2009-03-29
Keys 1-3 of 3 for "Michael Nausch".  Enter number(s), N)ext, or Q)uit > Q

Anschließend könnte auch einer der gefunden mit Angabe der Schlüssel-Nummer importiert werden:

# gpg --keyserver hkp://pgpkeys.pca.dfn.de --search-keys Michael Nausch
gpg: searching for "Michael Nausch" from hkp server pgpkeys.pca.dfn.de
(1)     Michael Nausch <michael@nausch.org>
        Michael Nausch (aka Django) <django@nausch.org>
        Michael Nausch (aka BigChief) <bigchief@omni128.de>
          1024 bit DSA key 2384C849, created: 2009-03-30
(2)     Michael Nausch (aka Django, BigChief) <michael@nausch.org>
          1024 bit DSA key B3648FCD, created: 2009-03-29
(3)     Michael Nausch (aka Django, aka BigChief) <michael@nausch.org>
          1024 bit DSA key 940A0CFC, created: 2009-03-29
Keys 1-3 of 3 for "Michael Nausch".  Enter number(s), N)ext, or Q)uit > 1
gpg: requesting key 2384C849 from hkp server pgpkeys.pca.dfn.de
gpg: key 2384C849: public key "Michael Nausch <michael@nausch.org>" imported
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: Total number processed: 1
gpg:               imported: 1

Dateioperationen

Unter Dateioperationen sollen folgende Punkte in Zusammenhang mit GnuPG behandelt werden:

  • Verschlüsseln von Dateien
  • Entschlüsseln von Dateien
  • Signieren von Dateien

Nachfolgende Operationen werden mit einer Test-Datei welche sich im Verzeichnis /tmp befindet und den Namen TestDatei.txt hat, durchgeführt. Der Inhalt der Datei /tmp/TestDatei.txt sieht folgendermaßen aus und kann mit nachfolgendem Befehl ausgegeben werden:

$ cat TestDatei.txt
Ich bin eine kleine Test-Datei :-)

Verschlüsseln von Dateien

Beim Verschlüsseln einer Datei kann zwischen zwei Ausgabeformaten gewählt werden:

  • binär
  • ASCII (kann leicht via e-Mail versendet werden)

Mit nachfolgenden Befehlen kann eine Datei im binären Format verschlüsselt werden:

$ gpg --encrypt /tmp/TestDatei.txt 
You did not specify a user ID. (you may use "-r")

Current recipients:

Enter the user ID.  End with an empty line: Klaus Tachtler

Current recipients:
4096g/902FD324 2009-06-03 "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Enter the user ID.  End with an empty line:
und ohne Nachfrage, welcher öffentliche Schlüssel verwendet werden soll, ebenfalls die Datei im binären Format verschlüsselt:
$ gpg --encrypt --recipient "Klaus Tachtler" /tmp/TestDatei.txt

Der Inhalt der so erzeugten Datei mit Namen /tmp/TestDatei.txt.gpg, würde nach einer Verschlüsselung im binären Format bei der Ausgabe mit nachfolgendem Befehl wie folgt aussehen:

$ cat /tmp/TestDatei.txt.gpg 
�Ñá┤├/Ó$
            �]��98�g�v�Kl���E�i�\��%�MϘ}��׆7�'��'⣧�6��+5��\ZS|
D ( PP¨≥¿¿+ȓZ┬¶†Ü$≤ˆ!UNä‹4—┴äO‘\O&�|�Gャ�{u^�nnwɶ������D����3bo�I��ʽ�̯���W�̉����T�8���Xx
@��hz�`�4\<\㗼\�:��^|*��I��<t$��A��o'�9b���>so�
�W'����(����.v�y9���{�阤�/�n��G���.q�f���[J���:��L�w�b��UxUu�"��p��{��@��m��k-��]xåd����2$�<���ႆ�/3�2�M��U�%=�A+B8;K�l���Ӌ
����.��/x��p�0��V�l����-]�g)p�;׿݋y�����]�-r��H-K8�bq��ӳ��Ŷ�?��G
                                              ל)T�g��S
�k�U ��_�w��^�Ĉ��R
     AU�ʰh�R�ľ�H=F�K��u�俐ex2���
                                     q(5�V4��`���yI�csz���`x{�{Du��6�ؾ�|��e�z�����RmK�6.���Oҭ�$6'°‘Ù─⎺ä\´,ý¾TKWÃúå·JSŠË^+─Û>°ãW        ¾Q±¸¦*É11¡à°┐
_␤_Ā¤ÔÎTìô\ˆÐȀ⎼ºUѺ
                         ƒ◆Ù    9„Eà„Ø⎺≥Îè‹@ùõ«␤≠┘!Œô©^│®Z3ÁµM¼Ï␋IˆéÿÅÊñ»␤␤␌¦ ⎽7àÞ±¸Õ┌™&‰žÅ├‡õìY,ä$F┴Ý%±ñÆ≠ú+ŸíG�:o�,�̌��i!$�v��?��L
@�嚙�?�p�ݘ����ly.%���e�����G�ƪ�#�c9��h���    q�T0>��%Sf���X��ʑ����K{?�c
                                                               �P��Nj7:���Y߹�Fϋh�&��Ll-�I(}�S=NP7��
                                                                                                          �Q̰�2[

Mit nachfolgenden Befehlen kann eine Datei im ASCII Format verschlüsselt werden:

$ gpg --armor --encrypt /tmp/TestDatei.txt 
You did not specify a user ID. (you may use "-r")

Current recipients:

Enter the user ID.  End with an empty line: Klaus Tachtler

Current recipients:
4096g/902FD324 2009-06-03 "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Enter the user ID.  End with an empty line:
und ohne Nachfrage, welcher öffentliche Schlüssel verwendet werden soll, ebenfalls die Datei im ASCII Format verschlüsselt:
$ gpg --armor --encrypt --recipient "Klaus Tachtler" /tmp/TestDatei.txt

Der Inhalt der so erzeugten Datei mit Namen /tmp/TestDatei.txt.asc, würde nach einer Verschlüsselung im ASCII Format bei der Ausgabe mit nachfolgendem Befehl wie folgt aussehen:

$ cat /tmp/TestDatei.txt.asc 
-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.5 (GNU/Linux)

hQQOA9HhdXSQL9MkEA/+KpZlIbkyDoqTAt9XegHxs3erNdy5O6BUR9+iJEqBqmdt
y6VPdPaKcYsOx/VdacoOU98trYqxneRWu8E4cgWUy+Fc1AqUTPGjjjQHNEyBFNOU
2sRj9iKXqZWkd1FzYTYI3eqglG588GmH0Jtt8V7fZ0ADangXS+xNzhs8iUCIdQ4n
XgGgA8Rw9o+onPgfDpL+kts5ADLoD2Yj/UUAku2Lbz7W3wPY3p57Hcfh3BafhsO5
3CVY6dxsZKjirAR5KD6YgK4Jc/oaCp5CVBu1w89H/zsaSnPKRG2jjOB9nN8G8CzD
Rk/1dUalpcUrTZA0UN2Dzf4ix34Xb5xfWeXeg7RFRf702yAcr6ijdZDjT9GZxHT1
SrfTDkwX+nWtcJTVRn16fEpQc7d8dcBhguztUKDgdbi1WtXuQpXhhe3gJGRjyvi4
17gXHwZCVhiNtWq5t4u42MAu0t6cyFPJvc1qPSHEnsjILy3fEJJo+P8hF3VNNyXx
vBc+687RhHckrNYusr8pdEV1lYpiQCN6/b+Yvn1LlzDPTjZTMfkWQ/7zWxcZu5Dq
ciV1a3P5tnm0+Iej3wkvhclpWpDH5+JvnUSw6rZIDCOZz4IEw9CR11ZPvh5uSPmI
oxUg2ywwb+Ht4Fdesh/fqD4MdmfsQhd7doGtoKs7wcL3G/nEfBDW5TtGTP6eVx4P
/3wjNga/uOQ7C1PI33d5o3GKLZbx+V9MiXkdGUKeqBRg0bPjQlxyc1jdMeSYACbG
dp46UJFtT3x7aXDfrc4wESGAm8VToxV/HiTQPXe8DPapRHj5atrM3nym/mLB7GF3
p9I/piS0wB2MtSSkvrT5a20ynCOr+JcyHyQ3xeRUIc26C//O2/13KYPj7QSjJ18s
C1xRUbPXQo1/q+QZgOBugqCDHdXf3Q1o8ZyYFZcXXqb3NhnRzbCmO6au92r0eN4p
utOaHRUVQIqHZ4BQHns8f+rmlYR2YysBbnsoYeveT2Fah659LJ8gf936ea+W2gJq
lmBtMWLYszlOVC5SQ3JZ5l6Qn3tPB9niCSI35kPBekBXEgIclghPAwczlR71x6NU
fyXDeC7et5efWQ73REfYxUqi/751RmENDug1N2xkaQBKZCm7XWMinIJXxjZSivtP
lg4rgWemGQLXpfmi2dPbfoBkalEeKJUUikxdXw/AI3x87eLDK+ZqCYJeLl7w+3Ya
71iXKqSsNMQkI+8Kha1aBohlSlb3Y0QjvEot693BonEw87/XH7o7JAoXKGitG7HX
bH1lWJEirir4NJtbl4sRX6Kru7DgonDfRad3rVPUkmDuFU1hvDjQstELYUqj6e+u
LLLRlHtR7+fBukJRFcIKsWxbW8JRGt46bQBxpf+vCQi+0mMBQbzBSbdt1re1NaG1
DQhqN9rfSwYsmqsEJU7ltCKfTvRbvzlSkwSNW/nPcS+FWXUlcd6CLOcohizu+Z6x
iq55sVdIerHuuqxi6DOZFaax37EXF+BVloks7gY4q6isqvzHUi4=
=sERo
-----END PGP MESSAGE-----

Entschlüsseln von Dateien

:!: Beim Entschlüssen spielt es keine Rolle, ob die verschlüsselte Datei im binär- oder ASCII-Format vorliegt!

Mit nachfolgenden Befehlen kann eine Datei egal in welchem Format diese verschlüsselt wurde entschlüsselt werden:

$ gpg --decrypt /tmp/TestDatei.txt.asc 

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
4096-bit ELG-E key, ID 902FD324, created 2009-06-03 (main key ID 8B7684D4)

Enter passphrase:

gpg: encrypted with 4096-bit ELG-E key, ID 902FD324, created 2009-06-03
      "Klaus Tachtler (klaus) <klaus@tachtler.net>"
Ich bin eine kleine Test-Datei :-)
und mit Ausgabeumleitung in eine Datei, sieht der Befehl so aus:
$ gpg --decrypt /tmp/TestDatei.txt.asc > /tmp/TestDatei.txt.decrypted

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
4096-bit ELG-E key, ID 902FD324, created 2009-06-03 (main key ID 8B7684D4)

gpg: encrypted with 4096-bit ELG-E key, ID 902FD324, created 2009-06-03
      "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Auch hier wieder die entschlüsselte Datei mit nachfolgendem Befehl ausgegeben:

$ cat /tmp/TestDatei.txt.decrypted 
Ich bin eine kleine Test-Datei :-)

:!: HINWEIS - Die Option –decrypt kann weg gelassen werden, da das Entschlüsseln die Standard-Operation ist!

Signieren von Dateien

Um die Echtheit und Unveränderlichkeit einer Datei mit einer Signatur dieser Datei zu bestätigen, gibt es mehrer Möglichkeiten:

1. Möglichkeit

Erzeugt eine Unterschrift, komprimiert die Original-Datei und schreibt beides im binär-Format in eine neue Datei mit der Endung gpg. Diese Datei enthält die Original-Datei zwar im binär-Format, jedoch :!: NICHT verschlüsselt!

$ gpg --sign /tmp/TestDatei.txt

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
1024-bit DSA key, ID 8B7684D4, created 2009-06-03

Enter passphrase:

Für eine Überprüfung der so signierten Datei mit nachfolgendem Befehl, ist die Original-Datei nicht notwendig:

$ gpg --verify /tmp/TestDatei.txt.gpg 
gpg: Signature made Fri 05 Jun 2009 11:44:50 AM CEST using DSA key ID 8B7684D4
gpg: Good signature from "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Der Inhalt der so signierten Datei kann mit nachfolgendem Befehl ausgegeben werden:

$ cat /tmp/TestDatei.txt.gpg 
v艄e۾yo���孁��z%%^/�<�3�2�R3�R�s�H�.X����&W�=3+H-�$A&���,b*�36�氅���0�o��g

2. Möglichkeit

Erzeugt eine Unterschrift, komprimiert die Original-Datei und schreibt beides im ASCII-Format in eine neue Datei mit der Endung asc. Diese Datei enthält die Original-Datei im ASCII-Format, ebenfalls :!: NICHT verschlüsselt!

$ gpg --armor --sign /tmp/TestDatei.txt

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
1024-bit DSA key, ID 8B7684D4, created 2009-06-03

Enter passphrase:

Für eine Überprüfung der so signierten Datei mit nachfolgendem Befehl, ist die Original-Datei nicht notwendig:

$ gpg --verify /tmp/TestDatei.txt.asc
gpg: Signature made Fri 05 Jun 2009 11:57:11 AM CEST using DSA key ID 8B7684D4
gpg: Good signature from "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Der Inhalt der so signierten Datei kann mit nachfolgendem Befehl ausgegeben werden:

$ cat /tmp/TestDatei.txt.asc 
-----BEGIN PGP MESSAGE-----
Version: GnuPG v1.4.5 (GNU/Linux)

owGbwMvWwCQYxzh5T3dZyxXGNWZJvCGpxSUuiSWpmXolFSVeGq+/eyZnKCRl5imk
ZualKmTngCmQIl2wKgUwXU2uDntmVgaQWphJgkzbkxjme0yZkcIu4bRvg063nOSy
O0yyA0r9GeYK1j3+xTVhTa2Vc8S9Fv3Pcik2240A
=HqQ9
-----END PGP MESSAGE-----

3. Möglichkeit

Erzeugt eine Unterschrift und schreibt beides, die Original-Datei in lesbarer Form und die signatur in eine neue Datei mit der Endung asc. Diese Datei enthält die Original-Datei in lesbarer Form, ebenfalls alles :!: NICHT verschlüsselt!

$ gpg --clearsign /tmp/TestDatei.txt

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
1024-bit DSA key, ID 8B7684D4, created 2009-06-03

Enter passphrase:

Für eine Überprüfung der so signierten Datei mit nachfolgendem Befehl, ist die Original-Datei nicht notwendig:

$ gpg --verify /tmp/TestDatei.txt.asc
gpg: Signature made Fri 05 Jun 2009 12:10:13 PM CEST using DSA key ID 8B7684D4
gpg: Good signature from "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Der Inhalt der so signierten Datei kann mit nachfolgendem Befehl ausgegeben werden:

]$ cat /tmp/TestDatei.txt.asc
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Ich bin eine kleine Test-Datei :-)
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)

xD8DBQFUUO8FXgGTxIt2hNQRAq+yAJ9kDCvCX3AjnIABdufkIdfQSzsdkACfe1y8
SqDpvPqWcCEnTeqryTawG/4=
=bx5L
-----END PGP SIGNATURE-----

4. Möglichkeit

Erzeugt eine Unterschrift, komprimiert die Original-Datei und schreibt beides im binär-Format in eine neue Datei mit der Endung sig. Diese Datei enthält die Original-Datei zwar im binär-Format, jedoch :!: NICHT verschlüsselt!

$ gpg --detach-sign /tmp/TestDatei.txt

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
1024-bit DSA key, ID 8B7684D4, created 2009-06-03

Enter passphrase:

Für eine Überprüfung der so signierten Datei mit nachfolgendem Befehl, ist die Original-Datei notwendig:

$ gpg --verify /tmp/TestDatei.txt.sig /tmp/TestDatei.txt
gpg: Signature made Fri 05 Jun 2009 01:15:43 PM CEST using DSA key ID 8B7684D4
gpg: Good signature from "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Der Inhalt der so signierten Datei kann mit nachfolgendem Befehl ausgegeben werden:

$ cat /tmp/TestDatei.txt.sig
��S�7��zyAZ���������+<G0�0&����$��yP[

5. Möglichkeit

Erzeugt eine Unterschrift, komprimiert die Original-Datei und schreibt beides im ASCII-Format in eine neue Datei mit der Endung asc. Diese Datei enthält die Original-Datei im ASCII-Format, ebenfalls :!: NICHT verschlüsselt!

$ gpg --armor --detach-sign /tmp/TestDatei.txt

You need a passphrase to unlock the secret key for
user: "Klaus Tachtler (klaus) <klaus@tachtler.net>"
1024-bit DSA key, ID 8B7684D4, created 2009-06-03

Enter passphrase:

Für eine Überprüfung der so signierten Datei mit nachfolgendem Befehl, ist die Original-Datei notwendig:

$ gpg --verify /tmp/TestDatei.txt.asc /tmp/TestDatei.txt
gpg: Signature made Fri 05 Jun 2009 01:19:47 PM CEST using DSA key ID 8B7684D4
gpg: Good signature from "Klaus Tachtler (klaus) <klaus@tachtler.net>"

Der Inhalt der so signierten Datei kann mit nachfolgendem Befehl ausgegeben werden:

$ cat /tmp/TestDatei.txt.asc
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)

iD8DCQBKKP9T>gGTvYt2hNQRBsIYAJ99mqjBn21NDCvadprFHBEceqVmVBCfRd4N
WlpLRr5HwpNkQud0NLRitzo=
=sGmT
-----END PGP SIGNATURE-----

Befehlsglossar

Hier ist eine Liste der gebräuchlichsten Befehle

Befehl Beschreibung
gpg --gen-key
Schlüsselpaar generieren
gpg --list-keys
Inhalt des öffentlichen Schlüsselrings ausgeben
gpg --list-sigs
Inhalt und Signaturen des öffentlichen Schlüsselrings ausgeben
gpg --list-secret-keys
Inhalt des privaten Schlüsselrings ausgeben
gpg --gen-revoke <key ID>
Erstellen eines Rückrufzertifikates für einen bestimmten Schlüssel
gpg --import <key ID/file>
Importieren eines (Rückruf)-Zertifikates/Keys in den öffentlichen Schlüsselring
gpg --edit-key <key/attribute>
Bearbeiten eines Schlüssels im öffentlichen Schlüsselring
gpg --export <key ID> > <file>
Exportieren eines Schlüssels aus dem öffentlichen Schlüsselring in eine Datei (binär)
gpg --export --armor <key ID> > <file>
Exportieren eines Schlüssels aus dem öffentlichen Schlüsselring in eine Datei (ASCII)
gpg --export-secret-keys <key ID> > <file>
Exportieren eines Schlüssels aus dem privaten Schlüsselring in eine Datei (binär)
gpg --export-secret-keys --armor <key ID> > <file>
Exportieren eines Schlüssels aus dem privaten Schlüsselring in eine Datei (ASCII)
gpg --armor --export-secret-keys <key ID> | gpg --armor 
--symmetric --cipher-algo AES256 > <file>
Exportieren eines Schlüssels aus dem privaten Schlüsselring in verschlüsselter Form
gpg --keyserver <keyserver> --send-key <key ID>
Exportieren eines Schlüssels aus dem öffentlichen Schlüsselring auf einen Keyserver
gpg --keyserver <keyserver> --recv-key <key ID>
Importieren eines Schlüssels in dem öffentlichen Schlüsselring von einem Keyserver
gpg --fingerprint <key/attribute>
Erstellen eines fingerprint für einen öffentlichen Schlüssel aus dem Schlüsselring
gpg --list-sigs <key/attribute>
Anzeige der Signierungen für einen öffentlichen Schlüssel aus dem Schlüsselring
gpg --keyserver <keyserver> --search-keys <key/attribute>
Suchen nach einem öffentlichen Schlüssel auf einem Keyserver
gpg --encrypt <file>
Verschlüsseln einer Datei im binär-Format –> <file>.gpg
gpg --armor --encrypt <file>
Verschlüsseln einer Datei im ASCII-Format –> <file>.asc
gpg --encrypt --recipient <user ID> <file>
Verschlüsseln einer Datei im binär-Format mit Schlüsselangabe –> <file>.gpg
gpg --armor --encrypt --recipient <user ID> <file>
Verschlüsseln einer Datei im ASCII-Format mit Schlüsselangabe–> <file>.asc
gpg <file>
Entschlüsseln einer Datei Format unabhängig
gpg --decrypt <file>
Entschlüsseln einer Datei Format unabhängig
gpg --decrypt <file> > <file>
Entschlüsseln einer Datei Format unabhängig mit Ausgabe in eine Datei
gpg --sign <file>
Signieren einer Datei im binär-Format → <file>.gpg –> ohne Original-Datei
gpg --armor --sign <file>
Signieren einer Datei im ASCII-Format → <file>.asc –> ohne Original-Datei
gpg --clearsign <file>
Signieren einer Datei in lesbarer-Form → <file>.asc –> ohne Original-Datei
gpg --detach-sign <file>
Signieren einer Datei im binär-Format → <file>.sig –> mit Original-Datei
gpg --armor --detach-sign <file>
Signieren einer Datei im ASCII-Format → <file>.asc –> mit Original-Datei
gpg --verify <file>
Verifizieren einer Datei Format unabhängig –> ohne Original-Datei
gpg --verify <file> <orig-file>
Verifizieren einer Datei Format unabhängig –> mit Original-Datei
gpg --version
Ausgabe der Version von GnuPG
Cookies helfen bei der Bereitstellung von Inhalten. Durch die Nutzung dieser Seiten erklären Sie sich damit einverstanden, dass Cookies auf Ihrem Rechner gespeichert werden. Weitere Information
tachtler/gnupg.txt · Zuletzt geändert: 2014/09/27 07:17 von klaus