Nitrokey Pro in der Praxis unter CentOS 7.x

In diesem Kapitel befassen wir uns eingehend mit dem Nitrokey Pro unter CentOS 7.x. Neben der verbesserten Absicherung von Login mit Einmalpasswörtern können eMails mit Hilfe von asymmetrischen Schlüsselmaterials (PGP und S/MIME) auch Dateien und ganze Festplatten verschlüsselt und natürlich auch wieder entschlüsselt werden. Hierzu verwenden wir den Nitrokey Pro welcher hier für einen überschaubaren Betrag von nicht einmal 50€ erstanden werden kann. In dem folgenden Beitrag gehen wir auf die Besonderheiten bei der Verwendung unter CentOS 7.x ein.

Der Nitrokey Pro Cryptostick vereint in einem kleinen Plastikgehäuse einen Kartenleser mit zugehöriger manipulationssicheren OpenPGP Chipkarte, einem zu 100% Open Source und Open Hardware Device. Wie schon erwähnt wird das geheime Schlüsselmaterial (RSA 2048-4096 Bit, ECC 256-512 Bit) im manipulations- und PIN-geschützten integrierten Chipkarte gespeichert und somit bestens gegen Schadcode oder Verlust bzw. Diebstahl und gegen Hardware-Angriffe geschützt.

Anwendungsfälle und Einsatzszenarien:

• Sicheres Login
  Einmalpassworte können zur Zweitauthentisierung bei vielen Webanwendungen oder Web-Diensten genutzt werden. Darüber hinaus ist auch eine Verwendung bei der Anmeldung an Rechnern oder z.B. bei der Anmeldung an entfernten Systemen mittels Zertifikaten und Schlüsseln bei SSH umsetzbar.
• Verschlüsselung rund um eMails
  Zur vertraulichen Kommunikation via eMail kann das benötigte Schlüsselmaterial auf dem Kryptostick Nitrokey Pro erzeugt und sicher verwahrt werden. Eine Verwendung unter GnuPG, OpenPGP oder S/MIME ist somit gegeben.
• Verschlüsselung von Dateien und Massenspeichern(Festplatten)
  Auch hier wird das geheime Schlüsselmaterial, wie auch schon beim Anwendungsfall eMail-Kommunikation, auf dem Kryptostick generiert und sicher vorgehalten. Eine Ver- und Entschlüsselung unserer Daten mit Hilfe von TrueCrypt, GnuPG Tools oder weiteren Anwendungen steht also nichts im Wege.

Weitere Informationen zum USB-Stick Nitrokey Pro findet findet man auch hier bzw. im Support Forum.

Darüber hinaus ist das 100%-Open PCB-Hardware-Design, sowie die Firmware und der Software SourceCode der Nitrokey-Familie in Github hinterlegt und einsehbar.

Informationen über den Stick können wir mit Hilfe des Befehls usb-devices aus dem RPM-Paket usbutils dem System abverlangen.

 # usb-devices

T:  Bus=02 Lev=02 Prnt=02 Port=01 Cnt=02 Dev#= 26 Spd=12  MxCh= 0
D:  Ver= 1.10 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs=  1
P:  Vendor=20a0 ProdID=4108 Rev=01.00
S:  Manufacturer=Nitrokey
S:  Product=Nitrokey Pro
S:  SerialNumber=000000000000000000006FDA
C:  #Ifs= 2 Cfg#= 1 Atr=80 MxPwr=100mA
I:  If#= 0 Alt= 0 #EPs= 1 Cls=03(HID  ) Sub=01 Prot=01 Driver=usbfs
I:  If#= 1 Alt= 0 #EPs= 3 Cls=0b(scard) Sub=00 Prot=00 Driver=(none)

Mit Hilfe des Befehls lsusb aus dem RPM-Paket usbutils können wir auch die Produkt- und Hersteller-Identifikationsnummer des Nitrokey-Sticks ermitteln.

 # lsusb
Bus 002 Device 026: ID 20a0:4108 Clay Logic 

Im Syslog wird uns beim Anstecken des Sticks dies entsprechend protokolliert:

Nov 16 17:49:39 T410 kernel: usb 2-1.2: new full-speed USB device number 27 using ehci-pci
Nov 16 17:49:39 T410 kernel: usb 2-1.2: New USB device found, idVendor=20a0, idProduct=4108
Nov 16 17:49:39 T410 kernel: usb 2-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Nov 16 17:49:39 T410 kernel: usb 2-1.2: Product: Nitrokey Pro
Nov 16 17:49:39 T410 kernel: usb 2-1.2: Manufacturer: Nitrokey
Nov 16 17:49:39 T410 kernel: usb 2-1.2: SerialNumber: 000000000000000000006FDA
Nov 16 17:49:39 T410 kernel: input: Nitrokey Nitrokey Pro as /devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2/2-1.2:1.0/input/input38
Nov 16 17:49:39 T410 kernel: hid-generic 0003:20A0:4108.001F: input,hidraw2: USB HID v1.10 Keyboard [Nitrokey Nitrokey Pro] on usb-0000:00:1d.0-1.2/input0
Nov 16 17:49:39 T410 mtp-probe: checking bus 2, device 27: "/sys/devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.2"
Nov 16 17:49:39 T410 mtp-probe: bus: 2, device: 27 was not an MTP device
Nov 16 17:49:39 T410 systemd: Reached target Smart Card.
Nov 16 17:49:39 T410 systemd: Starting Smart C

Für den Zugriff auf die SmartCard bzw. auf den Nitrokey Pro benötigen wir z.B. für GPG den SmartCard-Daemon scdeamon welcher bei CentOS 7 mit Hilfe es Pakets gnupg2-smime bereitgestellt wird.

Dieses Paket installieren wir nun noch via yum.

 #  yum install gnupg2-smime -y

Leider ist das Paket an sich aus Sicht der Entwickler des Kryptostick in einer nicht aktuellen Version bei CentOS 7 verfügbar (CentOS 7: 2.0.22 - aktuelle Version: 2.2.11)¹⁾. Das hat leider zur Folge, dass wir die PGP-Schlüssel nicht direkt auf der SmartCard generieren können, sondern diesen wie gewohnt auf dem Rechner erzeugen und anschliessend auf den Nitrokey Pro Stick verschoben werden muss.

Für den Betrieb unter CentOS 7 müssen wir uns noch passende udev-Definitionen hier besorgen und unserer Umgebung anpassen. Dies ist notwendig, da sonst die Gerätedatei nicht mit den entsprechenden Benutzer-Rechten angelegt wird! Wir wechseln also erst einmal in das entsprechende Konfigurationsverzeichnis /etc/udev/rules.d/.

 # cd /etc/udev/rules.d/

Dann holen wir uns die entsprechende Musterdatei auf unseren Rechner.

 # wget https://www.nitrokey.com/sites/default/files/41-nitrokey.rules

Wie schon erwähnt ist es unter CentOS 7 notwendig für unseren Benutzer eine Änderung an der Berechtigung der Gerätedatei vorzunehmen. Grundsätzlich gibt es hierzu zwei Varianten:

1. Dateirechte : Wir sorgen dafür dass auf die Gerätedatei /dev/hidraw0 jeder lesend und schreibend zugreifen kann, in dem wir die Dateirechte auf 666 setzen, oder
2. Nutzerrechte : wir sorgen dafür dass die Gerätedatei /dev/hidraw0 direkt unserem Benutzer, mit dem wir uns an unserem Rechner anmelden, gehört.

Wir entscheiden uns hier für die Option 2., wir sorgen also dafür dass die Gerätedatei unserem Nutzer - in diesem Konfigurationsbeispiel dem Benutzer django gehört, sobald dieser den Kryptostick in einen USB-Port steckt.

Zunächst legen wir als erstes mal die Gruppe plugdev an.

 # groupadd plugdev

Dann setzen wir unseren Benutzer django in diese Gruppe plugdev.

 # usermod -aG plugdev django

Nun passen wir noch die eingangs heruntergeladene udev-Regeldatei /etc/udev/rules.d/41-nitrokey.rules an. Der entscheidende Zusatz ist nun hier die Option OWNER=„django“.

 # vim /etc/udev/rules.d/41-nitrokey.rules

/etc/udev/rules.d/41-nitrokey.rules

# Nitrokey U2F
KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", OWNER="django", GROUP="plugdev", ATTRS{idVendor}=="2581", ATTRS{idProduct}=="f1d0"
# Nitrokey FIDO U2F
KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", OWNER="django", GROUP="plugdev", ATTRS{idVendor}=="20a0", ATTRS{idProduct}=="4287"
 
SUBSYSTEM!="usb", GOTO="gnupg_rules_end"
ACTION!="add", GOTO="gnupg_rules_end"
 
# USB SmartCard Readers
## Crypto Stick 1.2
ATTR{idVendor}=="20a0", ATTR{idProduct}=="4107", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", GROUP+="plugdev", TAG+="uaccess"
## Nitrokey Pro
#ATTR{idVendor}=="20a0", ATTR{idProduct}=="4108", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", GROUP+="plugdev", TAG+="uaccess"
ATTR{idVendor}=="20a0", ATTR{idProduct}=="4108", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", OWNER+="django", GROUP+="plugdev", TAG+="uaccess"
## Nitrokey Storage
ATTR{idVendor}=="20a0", ATTR{idProduct}=="4109", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", GROUP+="plugdev", TAG+="uaccess"
## Nitrokey Start
ATTR{idVendor}=="20a0", ATTR{idProduct}=="4211", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", GROUP+="plugdev", TAG+="uaccess"
## Nitrokey HSM
ATTR{idVendor}=="20a0", ATTR{idProduct}=="4230", ENV{ID_SMARTCARD_READER}="1", ENV{ID_SMARTCARD_READER_DRIVER}="gnupg", GROUP+="plugdev", TAG+="uaccess"
 
LABEL="gnupg_rules_end"

Zum Aktivieren unserer geänderten udev-Regeldatei lassen wir diese nun erneut einlesen; hierzu verwenden wir folgenden Befehl:

 # udevadm control --reload-rules

Sobald wir nun unseren Nitrokey Pro-Stick in einen USB-Port stecken wird die zugehörige Gerätedate mit den richtigen Berechtigungen angelegt. Hierzu verwenden wir die zum Stick passenden ANgaben, die wir mit lsusb ermittelt haben.

 # lsusb

Bus 002 Device 032: ID 20a0:4108 Clay Logic

 # ll /dev/bus/usb/002/032 

crw-rw-r--+ 1 django plugdev 189, 159 16. Nov 18:16 /dev/bus/usb/002/032

Für die Verwaltung des Sticks stellt uns Nitrokey eine entsprechende Anwendung bzw. App zur Verfügung. Die Softwarequellen finden wir im GitHub-Reposoitory. Auf der Downloadseite zu RedHat finden wir Angaben zum eigenen Repository, von dem wir ein passenden RPM-Paket installieen können.

Hierzu binden wir als erstes einmal das passende Repository auf unserem Rechner ein:

 # yum-config-manager --add-repo \\ 
   https://copr.fedorainfracloud.org/coprs/ignatenkobrain/Nitrokey-EL7/repo/epel-7/ignatenkobrain-Nitrokey-EL7-epel-7.repo

Das EPEL-Repository haben wir ja standardmäßig bereits eingebunden. Dieses wird für das Paket hidapi, eine Abhängigkeit des Paketes nitrokey-app, benötigt.

Nun installieren wir uns das Paket nitrokey-app mit Hilfe des Paketverwaltungswerkzeugs yum.

 # yum install nitrokey-app

Was uns das Paket alles mitgebracht hat können wir mit Hilfe nachfolgenden Befehls erkunden.

 # rpm -qil nitrokey-app

Name        : nitrokey-app
Version     : 1.2
Release     : 1.el7.centos
Architecture: x86_64
Install Date: Do 15 Nov 2018 17:43:50 CET
Group       : Unspecified
Size        : 939794
License     : GPLv3+
Signature   : RSA/SHA1, So 24 Dez 2017 22:24:56 CET, Key ID 36b570df607d9567
Source RPM  : nitrokey-app-1.2-1.el7.centos.src.rpm
Build Date  : So 24 Dez 2017 22:24:53 CET
Build Host  : copr-builder-238330759.novalocal
Relocations : (not relocatable)
URL         : https://github.com/Nitrokey/nitrokey-app
Summary     : Nitrokey's Application
Description :
Nitrokey's Application.
/usr/bin/nitrokey-app
/usr/lib/udev/rules.d/41-nitrokey.rules
/usr/share/applications/nitrokey-app.desktop
/usr/share/bash-completion
/usr/share/bash-completion/completions
/usr/share/bash-completion/completions/nitrokey-app
/usr/share/icons/hicolor/128x128/apps/nitrokey-app.png
/usr/share/icons/hicolor/16x16/apps/nitrokey-app.png
/usr/share/icons/hicolor/22x22/apps/nitrokey-app.png
/usr/share/icons/hicolor/24x24/apps/nitrokey-app.png
/usr/share/icons/hicolor/32x32/apps/nitrokey-app.png
/usr/share/icons/hicolor/48x48/apps/nitrokey-app.png
/usr/share/icons/hicolor/scalable/apps/nitrokey-app.svg
/usr/share/licenses/nitrokey-app-1.2
/usr/share/licenses/nitrokey-app-1.2/LICENSE
/usr/share/nitrokey
/usr/share/nitrokey/info.png
/usr/share/nitrokey/quit.png
/usr/share/nitrokey/safe_zahlenkreis.png
/usr/share/nitrokey/settings.png
/usr/share/pixmaps/nitrokey-app.png

Nun können wir die Anwendung starten. Wir finden diese entweder unter dem Menü Zubehör/Utilities im Anwendungsmenü oder wird starten das Programm einfach auf der Konsole.

 $ nextcloud-app

Der Start wird mit einem Eintrag in der oberen Statusleiste angezeigt.

Kurz nach dem Anstecken unseres Kryptosticks Nitrokey Pro wird uns in der Statusleiste am oberen Bildschirmrand ein Hinweis eingeblendet.

Die Smartcard, die im Nitrokey Pro bebaut wurde, ist mit zwei PINs geschützt, der Benutzer-PIN (Standard: 123456) und Admin-PIN (Standard: 12345678).

 $ wget https://www.nitrokey.com/sites/default/files/nitrokey-reset.txt

 $ gpg-connect-agent < nitrokey-reset.txt

Wir werden also zuerst einmal die beiden PINs abändern. Hierzu klicken wir mit der rechten Maustaste auf das Nitrokey-Symbol oben auf dem Desktop und wählen Sie das Menü „Konfigurieren“. Dort können wir nun sowohl die Benutzer- als auch Admin-PINs ändern.

Hier ändern wir nun die er Benutzer-PIN (Standard: 123456) sowie auch die Admin-PIN (Standard: 12345678) ab.

Der Kryptostick bietet uns die Möglichkeit bis zu 16 Passwörter anzuspeichern, die wir dann später einfach bei entsperrtem Nitrokey Pro Stick abrufen, in den Zwischenspeicher kopieren um es dann bei den (Web)Anwendungen einzufügen.

Damit wir unser ersten Passwort auf dem Stick ablegen können, ist es notwendig den Stick zu entsperren.

Nach der eingabe der PIN wird unser Kryptostick entsperrt und wir können anschließend den Menüpunkt Konfiguration erreichen.

Über den Menüpunkt Konfiguration gelangen wir zu den Einstellungen und wiederum auf dem Reiter Passwort-Safe dann die einstellungen zu den Anmeldedaten im Passwort-Safe.

Wollen wir uns nun später an einer (Web)-Anwendung anmelden, wählen wir aus der oberen Statusleiste die Nitrokey App aus und wählen beim Menüpunkt Paswörter den hinterlegte Passworteintrag aus.

Sobald wir diesen Eintrag anklicken wird das zugehörige Passwort in die Zwischenablage kopiert und wir können dies dann in das zugehörige Eingabemaske einfügen.

Da es sich bei der Chipkarte des Nitrokey Pro um eine standardkompatible OpenPGP-Karte handelt, kann der Kryptostick mit Hilfe von GnuPG verwaltet werden. Hierzu installieren wir uns das Paket gnupg2, sofern es nicht bereits bei der Erstkonfiguration unseres Rechner installiert wurde.

 # yum install gnupg2

Alle Sicherheitsfunktionen wie z.B. das Erzeugen/Speichern von GPG-Schlüsseln, das Verschlüsseln/Entschlüsseln einer Datei, das Signieren einer Nachricht, die auf der Hardware ausgeführt werden, können mit Hilfe des Befehls gpg bzw. gpg2, welches identisch mit gpg ist (!) gesteuert werden.

 $ gpg --card-status

gpg: selecting openpgp failed: Karte nicht vorhanden
gpg: OpenPGP Karte ist nicht vorhanden: Karte nicht vorhanden

Mit der Option card-status können wir uns mit dem Befehl gpg –card-status den Kartenstatus ausgeben lassen.

 $ gpg --card-status

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: [nicht gesetzt]
Language prefs ...: de
Sex ..............: unbestimmt
URL of public key : [nicht gesetzt]
Login data .......: [nicht gesetzt]
Signature PIN ....: nicht zwingend
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

Die einzelnen Datenfelder haben hierbei folgende Bedeutung:

Wie schon mit der Nitrokey App können wir auch mit Hilfe des Befehls gpg --change-pin die Benutzer- und die Admin-PIN, wie auch die PIN zum Zurücksetzen der Benutzer-PIN, ändern.

Die Benutzer-PIN (Menüpunkt 1) wird benötigt für den täglichen Betrieb wie z.B. zum Entsperren des Token, oder zum Signieren und Verschlüsseln. Die Mindestlänge für den User-Pin beträgt 6 Zeichen.

Die Admin-PIN (Menüpunkt 3) wird für die Karten-/Token-Verwaltung verwendet, so z.B. für das Laden von Schlüsseln auf den Krypto-Stick, das Erzeugen von Schlüsseln oder das Ändern von Informationen wie die Inhaberdaten auf der Karte. Die Mindestlänge für die Admin-PIN beträgt 8 Zeichen.

Die Reset-PIN (Menüpunkt 4) kann nur zum Zurücksetzen der Benutzer-PIN verwendet werden. Die Mindestlänge für den Reset-Code beträgt 8 Zeichen. Der Reset-Code Fehlerzähler kann wiederum mit der Admin-PIN zurückgesetzt werden. Wird nach zweimaliger Falscheingabe der Benutzer- wie auch der Admin-PIN und dann die richtige PIN eingeben, wird der Fehlerzähler zurückgesetzt.

Worin besteht nun aber der genaue Unterschied zwischen dem Reset-Code und der Admin-PIN? Möchte man in einer Organisation Nitrokey Pro an seine Mitarbeiter ausgeben, werden bestimmte Daten, wie z.B. Namen, die Public Key URL oder auch das erzeugte Schlüsselmaterial zentral vorgegeben. Da der Benutzer selbst diese Daten nicht verändern können soll, wird dieser auch nicht Kenntnis von der Admin-PIN haben. Sperrt sich nun der Mitarbeiter aus, weil er die Benutzer-PIN 3x falsch eingegeben hat, kann der Neutzer natürlich nicht die Admin-PIN eingeben, da er diese nicht kennt. Hier kommt nun der Reset-Code ins Spiel. Mit Hilfe dieses Codes kann der Benutzer nun die Benutzer-PIN zurücksetzen.

 $ gpg --change-pin

gpg: OpenPGP Karte Nr. D276000124010303000500006FDA0000 erkannt

1 - change PIN
2 - unblock PIN
3 - change Admin PIN
4 - set the Reset Code
Q - quit

Ihre Auswahl?

Beim Menüpunkt 1 können wir z.B. die Benutzer-PIN abändern. Wir werden dann nach der aktuellen PIN gefragt und müssen die neue PIN 2x eingeben zum Abändern.

Mit Hilfe des Befehls gpg --card-edit haben wir entsprechend umfangreiche Zugriffs-, Erstellungs- und Änderungsoptionen auf die Daten und das Schlüsselmaterial, welches auf der Smartcard gespeichert wurden und werden. Viele hilfreiche Informationen zum Umgang mit den Befehlen die uns das Programm gpg bietet, findet man in der zugehörigen Dokumentation auf der Projektseite von https://www.gnupg.org/.

 $ gpg --card-edit

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: [nicht gesetzt]
Language prefs ...: de
Sex ..............: unbestimmt
URL of public key : [nicht gesetzt]
Login data .......: [nicht gesetzt]
Signature PIN ....: nicht zwingend
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

gpg/card>

Mit Hilfe des Befehls help können wir uns anzeigen lassen, welche Optionen im jeweiligen Modus Benutzer oder Admin zur Verfügung stehen.

gpg/card> help

quit       Menü verlassen
admin      Zeige Admin-Befehle
help       Diese Hilfe zeigen
list       Alle vorhandenen Daten auflisten
fetch      Holen des Schlüssels mittels der URL auf der Karte
passwd     Menü für Ändern oder Entsperren der PIN
verify     überprüfe die PIN und liste alle Daten auf
unblock    die PIN mit dem Rückstellcode wieder freigeben

Mit dem Befehl admin können wir in den Admin-Modus/-Bereich wechseln und auch dort alle Befehle mit Hilfe von help anzeigen lassen.

gpg/card> admin

Admin-Befehle sind erlaubt

gpg/card> help

quit       Menü verlassen
admin      Zeige Admin-Befehle
help       Diese Hilfe zeigen
list       Alle vorhandenen Daten auflisten
name       Kartenbesitzernamen ändern
url        Schlüssel-holen-URL ändern
fetch      Holen des Schlüssels mittels der URL auf der Karte
login      Ändern der Logindaten
lang       Ändern der Spracheinstellungen
sex        Ändern des Geschlechts des Kartenbesitzers
cafpr      Ändern des CA-Fingerabdrucks
forcesig   Umschalten des "Signature-force-PIN"-Schalters
generate   neue Schlüssel erzeugen
passwd     Menü für Ändern oder Entsperren der PIN
verify     überprüfe die PIN und liste alle Daten auf
unblock    die PIN mit dem Rückstellcode wieder freigeben

Zunächst wollen wir unseren Stick personalisieren, also mit den Benutzerspezifischen Daten versorgen:

Zum Ändern dieser Daten müssen wir nach der Anmeldung an der Karte mit dem Befehl adminin den Admin Bereich wechseln.

 $ gpg --card-edit

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: [nicht gesetzt]
Language prefs ...: de
Sex ..............: unbestimmt
URL of public key : [nicht gesetzt]
Login data .......: [nicht gesetzt]
Signature PIN ....: nicht zwingend
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

gpg/card>

 gpg/card> admin

Admin-Befehle sind erlaubt

Wir ändern zunächst den Namen des Karteninhabers Name of cardholder:

 gpg/card> name

Familienname des Kartenbesitzers:aka BOfH
Vorname des Kartenbesitzers:Django

Als nächstes definieren wir die Sprache des Kartenbenutzers:

 gpg/card> lang

Spracheinstellungen de

Im nächsten Schritt setzen wir das Geschlecht des Karteninhabers:

 gpg/card> sex

Geschlecht: (Männlich (M), Weiblich (F) oder Leerzeichen): m

Nun setzen wir noch den Anmelde-/Loginnamen entsprechend unserer Umgebung:

 gpg/card> login

Logindaten (Kontenname): django

Zu guter Letzt setzen wir nun die URL, von der der public-key mit Hilfe des Befehls fetch unter gpg --edit-card auf die Karte geladen werden kann.

 gpg/card> url

URL um den öffentlichen Schlüssel zu holen: https://keyserver.nausch.org/pks/lookup?op=get&search=0x074ECF6150A6BFED

Somit ergeben sich folgende benutzerindividuellen Daten auf der Karte:

 gpg/card> verify 

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: Django aka BOfH
Language prefs ...: de
Sex ..............: männlich
URL of public key : https://keyserver.nausch.org/pks/lookup?op=get&search=0x074ECF6150A6BFED
Login data .......: django
Signature PIN ....: nicht zwingend
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

Nun können wir die Erstinitialisierung abschließen und den Einstellungsdialog mit dem Befehl quit verlassen.

 gpg/card> quit

Wir wollen uns nun einen neuen GPG-Schlüssel in der SmartCard erzeugen und rufen hierzu den Befehl generate auf. Wir werden nun menügeführt durch eine Reihe von Standardfragen geführt, welche alle relevante Daten abfragen, die zur Generierung des Hauptschlüssels wie auch der Unterschlüssel die für die Aufgaben Signatur, Verschlüsselung und Authentifizierung benötigt werden.

 $ gpg --card-edit

 gpg/card> admin

Admin-Befehle sind erlaubt

 gpg/card> generate

Sicherung des Verschlüsselungsschlüssel außerhalb der Karte erstellen? (J/n) n
Welche Schlüssellänge wünschen Sie für den Signatur-Schlüssel? (2048) 
Welche Schlüssellänge wünschen Sie für den Verschlüsselungs-Schlüssel? (2048) 
Welche Schlüssellänge wünschen Sie für den Authentisierungs-Schlüssel? (2048) 
Bitte wählen Sie, wie lange der Schlüssel gültig bleiben soll.
         0 = Schlüssel verfällt nie
      <n>  = Schlüssel verfällt nach n Tagen
      <n>w = Schlüssel verfällt nach n Wochen
      <n>m = Schlüssel verfällt nach n Monaten
      <n>y = Schlüssel verfällt nach n Jahren
Wie lange bleibt der Schlüssel gültig? (0) 
Schlüssel verfällt nie
Ist dies richtig? (j/N) j

GnuPG erstellt eine User-ID um Ihren Schlüssel identifizierbar zu machen.

Ihr Name ("Vorname Nachname"): Django aka BOfH
Email-Adresse: secmail@nausch.org
Kommentar: Bastard Operator from Hell
Sie haben diese User-ID gewählt:
    "Django aka BOfH (Bastard Operator from Hell) <secmail@nausch.org>"

Ändern: (N)ame, (K)ommentar, (E)-Mail oder (F)ertig/(A)bbrechen? f

gpg: key generation failed: Kartenfehler
Schlüsselerzeugung fehlgeschlagen: Kartenfehler

Da aktuell²⁾ die Generierung der Schlüsseldaten direkt auf der SmartCard scheitert, werden wir zunächste den Schlüssel wie gewohnt generieren und anschliessend in den Nitrokey Pro verschieben.

Zunächst erzeugen wir uns also einen PGP-Schlüssel, wie wir das sonst auch auf der Konsole machen würden.

 $ 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.

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: Django aka BOfH
Email address: secmail@nausch.org
Comment: 
You selected this USER-ID:
    "Django aka BOfH <secmail@nausch.org>"

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.
gpg: key D1359446 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/D1359446 2018-11-21
      Key fingerprint = FA63 2892 1925 65D3 E006  DC75 2ECB E36F D135 9446
uid                  Django aka BOfH <secmail@nausch.org>
sub   4096R/564BA287 2018-11-21

In unserem PGP-Schlüsselbund befinden sich nun unser gerade angelegt Schlüssel.

 $ gpg2 --list-secret-keys

/home/django/.gnupg/secring.gpg
------------------------------
sec   4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
ssb   4096R/564BA287 2018-11-21

Werfen wir zur genaueren Betrachtung einfach einen Blick in unseren Schlüsselbund.

 $ gpg2 --list-keys

/home/michi/.gnupg/pubring.gpg
------------------------------
pub   4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
sub   4096R/564BA287 2018-11-21

Obwohl wir zuvor „nur einen“ PGP-Schlüssel generiert generiert hatten, sehen wir nun aber plötzlich zwei Schlüssel. Der eine ist mit dem Wert pub gekennzeichnet und hat die Schlüssel-ID D1359446 und der zweite Schlüssel ist als sub gekennzeichnet und hat die Schlüssel-ID 564BA287.

Beide Schlüssel sehen wir auch, wenn wir uns den Inhalt des secrings anzeigen lassen:

 $ gpg2 --list-secret-keys

/home/django/.gnupg/secring.gpg
------------------------------
sec   4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
ssb   4096R/564BA287 2018-11-21

• Worin besteht nun der genaue Unterschied?
  Nun, der erste Schlüssel ist der primäre Signierungs-Schlüssel und der zweite Schlüssel ist ein Unterschlüssel für die Verschlüsselung, der Verschlüsselung-Schlüssel.
  
  
• Warum nun der ganze Aufstand mit diesem Unterschlüssel?
  Stellen wir uns einmal folgendes Szenario vor: Eines Tagen wollen oder müssen wir den privaten Schlüssel wechseln, da dieser kompromittiert wurde, oder wir stellen fest, dass die ursprünglich gewählte Schlüssellänge nicht mehr unserem gesteigertem Sicherheitsbewusstsein entspricht. Wir können natürlich den alten Schlüssel verwerfen, zurückziehen und löschen, damit dieser unbrauchbar wird. Nur verlieren wir dadurch natürlich sämtliche beglaubigte Unterschriften unserer Kontaktpersonen und Freunde, die ja einen gewissen Vertrauensstatus bezeugen -der Hintergrund zum WoT-Gedanken³⁾. Als Folge daraus müssten wir erneut den ganzen Aufwand mit dem Key-Signing betreiben, was mit unter sehr aufwändig werden könnte!
  Mit Unterschlüssel müssen wir nicht alles über Bord werden, sondern können z.B. weiterhin die beglaubigten Unterschriften unserer Freunde und Bekannten beibehalten und verwenden. Diese Signatur-Informationen sind, genau so wie die primäre User-ID, mit dem primären Signierungsschlüssel verknüpft! Subkeys selbst haben keine eigene Vertrauensstellung, sprich diese werden nicht selbst signiert. Der grosse Vorteil ist nun, dass wir diese Unterschlüssel für genau spezifizierte Einsatzzwecke definieren und nutzt können: Verschlüsselung, Signierung oder Authentifizierung. Diese Schlüssel können wir nun gezielt erneuern und dann an unsere Kontaktpersonen über den Master-Schlüssel verteilen können. Die Änderungen werden dann automatisch in deren Key-Rings als Aktualisierung des bestehenden Schlüssels übernommen, da die Unterschlüssel mit unserem Primary Signing Key signiert sind, dem unsere Kommunikationspartner ja schon bereits vertrauen.

Fragen wir den Status unseres Nitrokey Pro ab, so sehen wir dort am Ende drei Speicherplätze für unterschiedliche Unterschlüssel, genauer gesagt der private Teil der Unterschlüssel, die auf dem Nitrokey Pro gespeichert sind, nämlich den :

• Signature key : Unterschlüssel zum Signieren
• Encryption key : Unterschlüssel zum Verschlüsseln
• Authentication key: Unterschlüssel zum Authentifizieren

 $ gpg2 --card-status

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: [not set]
Language prefs ...: de
Sex ..............: unspecified
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

Damit wir nun die drei benötigten Unterschlüssel an die richtige Stelle unseres Nitrokey Pro verschieben können, müssen wir noch ein paar Vorbereitungen treffen:

1. Erstellen weiterer Unterschlüssel für die Themen:
   1. Signierung
   2. Authentifizierung
2. Verschieben der privaten Unterschlüssel aus dem Schlüsselbund, der auf der Festplatte gespeichert waren in die SmartCArd des Nitrokey Pros.
3. Verschieben des primären Signierungs Schlüssel auf ein sicheres Sicherungsmedium.

Die öffentlichen Schlüssel bleiben nach wie vor im Schlüsselbund auf unserer Festplatte /home/~/.gnupg/pubring.gpg gespeichert, lediglich die privaten Unterschlüssel werden durch Proxy-Einträge im Schlüsselbund ersetzt!

Bevor wir nun zum Punkt 1. Erstellen weiterer Unterschlüssel widmen können rufen wir uns die ID des rimären Siegnierungs-Schlüssel in Erinnerung.

 $ gpg2 --list-keys | grep pub

/home/michi/.gnupg/pubring.gpg
pub   4096R/D1359446 2018-11-21

In unserem Konfigurationsbeispiel hier ist dies die Key-ID: D1359446. Zunächst erstellen wir besagten Unterschlüssel zum Signieren:

$ gpg2 --expert --edit-key D1359446

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.

Secret key is available.

pub  4096R/D1359446  created: 2018-11-21  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096R/564BA287  created: 2018-11-21  expires: never       usage: E   
[ultimate] (1). Django aka BOfH <secmail@nausch.org>

gpg>

Das Erzeugen von Unterschlüssel erfolgt mit hilfe des Befehls addkey.

gpg> addkey

Key is protected.

You need a passphrase to unlock the secret key for
user: "Django aka BOfH <secmail@nausch.org>"
4096-bit RSA key, ID D1359446, created 2018-11-21

Please select what kind of key you want:
   (3) DSA (sign only)
   (4) RSA (sign only)
   (5) Elgamal (encrypt only)
   (6) RSA (encrypt only)
   (7) DSA (set your own capabilities)
   (8) RSA (set your own capabilities)
Your selection?

Da wir einen RSA-Unterschlüssel zum Signieren erzeugen möchten, wählen wir hier die Option 4. Bei der Schlüssellänge verwenden wir wie auch schon bei der Erstellung des initialen Schlüsselpaares 4096; die Laufzeit des Unterschlüssels wählen wir entsprechend gleich oder kürzer wie beim primären Signierungs-Schlüssel, in inserem Beispiel also unendlich.

Your selection? 4

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) 
Key does not expire at all
Is this correct? (y/N) y
Really create? (y/N) y
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.

pub  4096R/D1359446  created: 2018-11-21  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096R/564BA287  created: 2018-11-21  expires: never       usage: E   
sub  4096R/ACCE2639  created: 2018-11-21  expires: never       usage: S   
[ultimate] (1). Django aka BOfH <secmail@nausch.org>

gpg>

Das Gleiche machen wir nun erneut für unseren Authentifizierungs-Unterschlüssel.

 gpg> addkey

Key is protected.

You need a passphrase to unlock the secret key for
user: "Django aka BOfH <secmail@nausch.org>"
4096-bit RSA key, ID D1359446, created 2018-11-21

Please select what kind of key you want:
   (3) DSA (sign only)
   (4) RSA (sign only)
   (5) Elgamal (encrypt only)
   (6) RSA (encrypt only)
   (7) DSA (set your own capabilities)
   (8) RSA (set your own capabilities)
Your selection?

Für unseren Verschlüsselungs-Unterschlüssel wählen wir nun eben hier entsprechend die Option 8.

Your selection? 8

Possible actions for a RSA key: Sign Encrypt Authenticate 
Current allowed actions: Sign Encrypt 

   (S) Toggle the sign capability
   (E) Toggle the encrypt capability
   (A) Toggle the authenticate capability
   (Q) Finished

Your selection?

Uns wir nun angezeigt, dass aktuell Signierung und Verschlüsselung vorausgewählt wurde: Current allowed actions: Sign Encrypt. Wir wählen nun nacheinander die Optionen für Signierung mit „S“ und Verschlüsselung mit „E“ ab und Signierung mit „A“ an.

Your selection? s

Possible actions for a RSA key: Sign Encrypt Authenticate 
Current allowed actions: Encrypt 

   (S) Toggle the sign capability
   (E) Toggle the encrypt capability
   (A) Toggle the authenticate capability
   (Q) Finished

Your selection? e

Possible actions for a RSA key: Sign Encrypt Authenticate 
Current allowed actions: 

   (S) Toggle the sign capability
   (E) Toggle the encrypt capability
   (A) Toggle the authenticate capability
   (Q) Finished

Your selection? a

Possible actions for a RSA key: Sign Encrypt Authenticate 
Current allowed actions: Authenticate 

   (S) Toggle the sign capability
   (E) Toggle the encrypt capability
   (A) Toggle the authenticate capability
   (Q) Finished

Your selection?

An der nun definierten Option Current allowed actions: Authenticate sehen wir, dass nun nachfolgend ein Authentifizierungs-Unterschlüssel generiert werden soll. Mit Q Verlassen wir diesen Dialog und generieren den besagten Authentifizierungs-Unterschlüssel.

Your selection? q

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) 
Key does not expire at all
Is this correct? (y/N) y
Really create? (y/N) y
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.

pub  4096R/D1359446  created: 2018-11-21  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096R/564BA287  created: 2018-11-21  expires: never       usage: E   
sub  4096R/ACCE2639  created: 2018-11-21  expires: never       usage: S   
sub  4096R/EC65030E  created: 2018-11-21  expires: never       usage: A   
[ultimate] (1). Django aka BOfH <secmail@nausch.org>

GnuPG listet nun den Primary Schlüssel zum Signieren und alle Unterschlüssel auf mit dem jeweiligen Verwendungszweck usage auf. E steht für Verschlüsseln, S für Signieren und A für Athentifizierung.

Zu guter letzt speichern wir nun mit dem Befehl save unsere gerade erstellen Unterschlüssel im Schlüsselspeicher auf der Festplatte ab.

gpg> save

Fragen wir nun erneut den Schlüsselbund mit den secret-keys ab sehen wir nun unsere drei Unterschlüssel.

 $ gpg2 --list-secret-keys

/home/django/.gnupg/secring.gpg
------------------------------
sec   4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
ssb   4096R/564BA287 2018-11-21
ssb   4096R/ACCE2639 2018-11-21
ssb   4096R/EC65030E 2018-11-21

Nun werden wir die vorhin generierten Schlüssel an Ort und Stelle in die SmartCard des Nitrokey Pro verschieben. Hierzu verwenden wir den Befehl keytocard des Programms gpg2. Wie schon beim Generieren der Unterschlüssel müssen wir angeben, welche primäre Schlüssel-ID bearbeitet oder genauer gesagt verschoben werden soll. In unserem Konfigurationsbeispiel ist das die ID D1359446.

 $ gpg2 --edit-key D1359446

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.

Secret key is available.

pub  4096R/D1359446  created: 2018-11-21  expires: never       usage: SC  
                     trust: ultimate      validity: ultimate
sub  4096R/564BA287  created: 2018-11-21  expires: never       usage: E   
sub  4096R/ACCE2639  created: 2018-11-21  expires: never       usage: S   
sub  4096R/EC65030E  created: 2018-11-21  expires: never       usage: A   
[ultimate] (1). Django aka BOfH <secmail@nausch.org>

Für später merken wir uns nun in Welcher Reichenfolge die Unterschlüssel aufgelistet werden bzw. welche Key-ID zu welcher Aktion gehört. Die Key-ID **0** ist die des primären Signierungs-Schlüssel!
  * Sub-Key **1** - **564BA287** - **E** = encrypt = verschlüsseln
  * Sub-Key **2** - **ACCE2639** - **S** = sign = signieren
  * Sub-Key **3** - **EC65030E** - **A** = authorize = authentifizieren

gpg> 

Da wir die privaten Schlüssel unserer drei Unterschlüssel verschieben wollen, wechseln wir von der Ansicht der öffentlichen in die Ansicht der privaten Schlüssel.

gpg> 

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Als erstes verschieben wir den privaten Verschlüsselungs-Unterschlüssel. Hierzu wählen wir diesen mit Eingabe von „1“ ein. Die Auswajhl wird uns dann durch den * angezeigt.

gpg> key 1

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb* 4096R/564BA287  created: 2018-11-21  expires: never     
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Nun verschieben wir den ausgewählten Schlüssel in die SmartCard des Nitrokey. Als Ziel wählen wir dann richtiger Weise die Option 2 = Encryption key aus

gpg> keytocard

Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]

Please select where to store the key:
   (2) Encryption key
Your selection? 2

You need a passphrase to unlock the secret key for
user: "Django aka BOfH <secmail@nausch.org>"
4096-bit RSA key, ID 564BA287, created 2018-11-21


sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb* 4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Als nächstes verschieben wir den privaten Signierungs-Unterschlüssel aus, in dem wir erst den bereits ausgewählten Verschlüsselungs-Key abwählen und dann den Signierungs-Key anwählen.

gpg> key 1

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

gpg> key 2

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb* 4096R/ACCE2639  created: 2018-11-21  expires: never     
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Nun verschieben wir den privaten Signierungs-Unterschlüssel in Richtung SmartCard des Nitrokey Pro. Hier wählen wir nun die 1 für Signature key aus.

gpg> keytocard

Signature key ....: [none]
Encryption key....: A7CC 2F9D 0D39 92B6 B03A  A878 06CC CCAF 564B A287
Authentication key: [none]

Please select where to store the key:
   (1) Signature key
   (3) Authentication key
Your selection? 1

You need a passphrase to unlock the secret key for
user: "Django aka BOfH <secmail@nausch.org>"
4096-bit RSA key, ID ACCE2639, created 2018-11-21


sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb* 4096R/ACCE2639  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Zu guter Letzt fehlt nun noch unser Authentifizierungs-Unterschlüssel. Wir wählen also wieder den Schlüssel 2 ab und den Schlüssel 3 aus.

gpg> key 2

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

gpg> key 3

sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb* 4096R/EC65030E  created: 2018-11-21  expires: never     
(1)  Django aka BOfH <secmail@nausch.org>

Nun verschieben wir den privaten Authentifizierungs-Unterschlüssel in Richtung SmartCard des Nitrokey Pro. Hier wählen wir nun die 3 für Authentication key aus.

gpg> keytocard

Signature key ....: C78C 3294 2822 BFE2 3A0C  BF5B 7D77 3C74 ACCE 2639
Encryption key....: A7CC 2F9D 0D39 92B6 B03A  A878 06CC CCAF 564B A287
Authentication key: [none]

Please select where to store the key:
   (3) Authentication key
Your selection? 3

You need a passphrase to unlock the secret key for
user: "Django aka BOfH <secmail@nausch.org>"
4096-bit RSA key, ID EC65030E, created 2018-11-21


sec  4096R/D1359446  created: 2018-11-21  expires: never     
ssb  4096R/564BA287  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb  4096R/ACCE2639  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
ssb* 4096R/EC65030E  created: 2018-11-21  expires: never     
                     card-no: 0005 00006FDA
(1)  Django aka BOfH <secmail@nausch.org>

Zum Abschluss speichern wir nun unsere Änderungen im lokalen key-ring mit dem Befehl save.

gpg> save

Wenn wir jetzt den Kartenstatus abfragen, werden unsere drei Unterschlüssel entsprechend mit angezeigt.

 $ gpg2 --card-status

Application ID ...: D276000124010303000500006FDA0000
Version ..........: 3.3
Manufacturer .....: ZeitControl
Serial number ....: 00006FDA
Name of cardholder: [not set]
Language prefs ...: de
Sex ..............: unspecified
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: 4096R 4096R 4096R
Max. PIN lengths .: 64 64 64
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: C78C 3294 2822 BFE2 3A0C  BF5B 7D77 3C74 ACCE 2639
      created ....: 2018-11-21 11:58:41
Encryption key....: A7CC 2F9D 0D39 92B6 B03A  A878 06CC CCAF 564B A287
      created ....: 2018-11-21 09:05:29
Authentication key: 268A DDA5 30FD 8FE7 DD86  2C5B 4E9B 2B65 EC65 030E
      created ....: 2018-11-21 12:01:12
General key info..: pub  4096R/ACCE2639 2018-11-21 Django aka BOfH <secmail@nausch.org>
sec   4096R/D1359446  created: 2018-11-21  expires: never     
ssb>  4096R/564BA287  created: 2018-11-21  expires: never     
                      card-no: 0005 00006FDA
ssb>  4096R/ACCE2639  created: 2018-11-21  expires: never     
                      card-no: 0005 00006FDA
ssb>  4096R/EC65030E  created: 2018-11-21  expires: never     
                      card-no: 0005 00006FDA

Damit wir später unseren öffentlichen Schlüssel auch weitergeben oder zu einem Keyserver hochladen, exportieren wir diesen in eine Datei.

$ gpg --export --armor secmail@nausch.org > secmail@nausch.org.publickey

Diese Date enthält unseren Schlüssel in ASCCI-lesbarer Form.

$ cat  secmail@nausch.org.publickey

secmail@nausch.org.publickey

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v2.0.22 (GNU/Linux)
 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=ZvZy
-----END PGP PUBLIC KEY BLOCK-----

Nun werden wir kurz einmal testen, ob wir mit Hilfe der Hardware-Schlüssel-Karte eine Datei ver- und wieder entschlüsseln können.

1. Zunächst Wir legen uns erst einmal ein beliebiges Testdokument an.

    $ cat /etc/redhat-release > testdatei.txt

   Die Date hat nun folgenden Inhalt:

    $ cat testdatei.txt

   CentOS Linux release 7.5.1804 (Core)

2. Nun verschlüsseln wir dieses Textdokument:

    $ gpg2 -o testdatei.txt.pgp -a -r secmail@nausch.org -e testdatei.txt

   Wir haben also nun zwei Dokumente auf der Platte liegen.

    $ ll testdatei.txt*

   -rw-rw-r-- 1 django django  38 Nov 21 14:21 testdatei.txt
   -rw-rw-r-- 1 django django 962 Nov 21 14:37 testdatei.txt.pgp

   Die Datei testdatei.txt.pgp können wir nun soweit nicht mehr lesen.

    $ cat testdatei.txt.pgp

   �
     �̯VK��
   ��ꠔ��oY]�T>Jm��c������76]Ԛ�a&H
   SZ,(��                                    ��w��+�Ao؃�l|
   =�Y����v,C���}z�狒*�fU�H=��J�l�O�������颣�*�ݴ'��ɟ
                                 MQ[Ce<��)X�yS$�2��`=�
                                                       u�뇙�P����1<�R�cE���2
   cTj���|�@}~.t!���V?���q]�ѻ��MӚ��W�$
   ��߿�W.�-I����^�V�-��+A�i�                                                                                        �f��mi�pPw��mh����]���38n�w�Iб]��
                              L�����\�v�R
   *�]��-�t,-�A�9�6>�ZW�m������-�S{$�(}C@)��hZ
                                                ��QUw�~�[�F�%�:BB�TnD�8���`!�	'J�w�������!���LJ�PH�kj���k
   �����Q��u���s_���@�G��ʁ}!?D7݈.%w�[�xX�
   ِ����U��;���15���d����n
   �-;Z����x�3-MTt�i�L1̣�E�+���
                                      ��}��w�St�ls�
   ��6��n�#?��*('�㔛��y�,	�j�	�ᡞ���M/��YW��ݤ�r؎�B$�

3. Nun entschlüsseln wir unser Dokument wieder.

    gpg2 --decrypt testdatei.txt.pgp > testdatei-entschlüsselt.txt

   gpg: encrypted with 4096-bit RSA key, ID 564BA287, created 2018-11-21
         "Django aka BOfH <secmail@nausch.org>

   Den Inhalt dieser Datei können wir nun nach erfolgter Entschlüsselung natürlich wieder lesen.

    $ cat testdatei-entschlüsselt.txt

   CentOS Linux release 7.5.1804 (Core)

Löschen wir nun den kompletten Schlüssel aus der lokalen Schlüsseldatei, können wir folgenden Befehl verwenden.

 $ gpg --delete-secret-key secmail@nausch.org

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.


sec  4096R/D1359446 2018-11-21 Django aka BOfH <secmail@nausch.org>

Delete this key from the keyring? (y/N) y
This is a secret key! - really delete? (y/N) y

Der gpg-Befehl --delete-secret-keys hat als Bezugspunkt den primären Signierungsschlüssel und würde beim entfernen dieses Schlüssels natürlich auch die Unterschlüssel entfernen. Da wir nur den privaten primären Signierungsschlüssel aus dem Schlüsselbund löschen wollen, exportieren wir die privaten Unterschlüssel, bevor wir den privaten Primary Signing Key löschen und werden diese dann anschließend wieder importieren.

Wir exportieren also erst einmal die Unterschlüssel und legen diese in einer lokalen Datei ab. Zunächst holen wir uns aber noch die Schlüssel-IDs da wir diese beim Exportieren eiegns angeben müssen.

 $ gpg2 --list-secret-keys

/home/django/.gnupg/secring.gpg
------------------------------
sec   4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
ssb>  4096R/564BA287 2018-11-21
ssb>  4096R/ACCE2639 2018-11-21
ssb>  4096R/EC65030E 2018-11-21

Nun exportieren wir die Unterschlüssel mit Hilfe folgenden Aufrufs, bei dem wir die IDs der Unterschlüssel gfolgt von einem ! jeweils angeben:

 $ gpg2 -o subkeys --export-secret-subkeys 564BA287! ACCE2639! EC65030E!

Nun löschen wir den primären Signierungsschlüssel inkl. der Unterschlüssel.

 $ gpg2 --delete-secret-key secmail@nausch.org

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.


sec  4096R/D1359446 2018-11-21 Django aka BOfH <secmail@nausch.org>

Delete this key from the keyring? (y/N) y
This is a secret key! - really delete? (y/N) y

Ein erneuter Aufruf des privaten Schlüsselspeichers zeigt und, dass dort nun keine Einträge mehr vorhanden sind.

 $ gpg2 --list-secret-keys

Nun importieren wir wieder die zuvor gesicherten privaten Unterschlüssel

 $ gpg2 --import subkeys

gpg: key D1359446: secret key imported
gpg: key D1359446: "Django aka BOfH <secmail@nausch.org>" not changed
gpg: Total number processed: 1
gpg:              unchanged: 1
gpg:       secret keys read: 1
gpg:   secret keys imported: 1

Lassen wir uns nun den Inhalt des privaten Schlüsselbundes anzeigen, sehen wir die zurückgesicherten Unterschlüssel wieder.

 $ gpg2 --list-secret-keys

/home/django/.gnupg/secring.gpg
------------------------------
sec#  4096R/D1359446 2018-11-21
uid                  Django aka BOfH <secmail@nausch.org>
ssb>  4096R/564BA287 2018-11-21
ssb>  4096R/ACCE2639 2018-11-21
ssb>  4096R/EC65030E 2018-11-21

Zu guter letzt vernichten wir die Datei mit den gesicherten privaten Unterschlüsseln.

 $ shred --zero --removesubkeys

Unseren zuvor präparierten Kryptostick wollen wir nun verwenden um bei Thunderbird unsere elektronische Kommunikation per eMail abzusichern. Hierzu werden wir nun den schlüssel dem betreffenden Konto zuweisen. Über das Menü wählen wir den Punkt Konten-Einstellungen aus.

Beim passenden Konto wählen wir dann die Option OpenPGP-Sicherheit aus.

Hier wählen wir nun den Schlüssel aus, den wir zuvor erstellt und auf die SmartCard des Kryptostick Pro verschoben hatten.

Sobald wir nun eine Nachricht verschicken die signiert werden soll, wird vor dem Versand die PIN abgefragt und die Nachricht mit dem Signatur-Unterschlüssel unterschrieben.

Sobald wir eine verschlüsselte Nachricht öffnen, werden wir nach der PIN gefragt, damit der Schlüssel zum Entschlüsseln auf der SmartCard freigeschalten werden kann.

Habne wir die PIN richtig eigegeben, wird die entschlüsselte Nachricht angezeigt.