Nitrokey 3C NFC und Nitrokey 3A mini in der Praxis unter Linux Mint 21.2 (Victoria)
In diesem Kapitel befassen wir uns eingehend mit dem Nitrokey 3C NFC und Nitrokey 3A mini unter Linux Mint 21.2 (Victoria). Weitere Informationen zu den Nitrokey-Sticks findet man auch hier bzw. im Support Forum.
Der neue Nitrokey 3 wahlweise mit mit NFC, USB-C oder USB-A Mini sowie Rust, Common Criteria EAL 6+
Der neue Nitrokey 3 ist der beste Nitrokey den wir je entwickelt haben. Er bietet erstmals NFC, USB-C. Der Nitrokey 3 vereint die Funktionen vorheriger Nitrokey Modelle: FIDO2, Einmalpasswörter, OpenPGP Chipkarte, Curve25519, Passwort-Manager, Common Criteria EAL 6+ zertifiziertes Secure Element, Firmware-Updates. Damit werden Ihre Accounts zuverlässig gegen Phishing und Passwort-Diebstahl geschützt und Ihre Kommunikation und Daten verschlüsselt. Mit starker Hardware-Verschlüsselung, vertrauenswürdig dank Open Source, Qualität made in Germany.
Quelle: https://shop.nitrokey.com/de_DE/shop/product/nk3cn-nitrokey-3c-nfc-148
Mit Hilfe von asymmetrischen Schlüsselmaterials (PGP und S/MIME) können eMails sowie Dateien und ganze Festplatten verschlüsselt und natürlich auch wieder entschlüsselt werden. Hierzu verwenden wir den Nitrokey 3C NFC welcher hier für einen Betrag von 49 € erstanden werden kann. In dem folgenden Beitrag gehen wir auf die Verwendung unter Linux Mint 21.2 (Victoria) ein.
Hardwareinformationen
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=01 Lev=02 Prnt=02 Port=01 Cnt=01 Dev#= 11 Spd=12 MxCh= 0 D: Ver= 2.10 Cls=ef(misc ) Sub=02 Prot=01 MxPS=64 #Cfgs= 1 P: Vendor=20a0 ProdID=42b2 Rev=01.04 S: Manufacturer=Nitrokey S: Product=Nitrokey 3 C: #Ifs= 4 Cfg#= 1 Atr=80 MxPwr=100mA I: If#= 0 Alt= 0 #EPs= 2 Cls=0b(scard) Sub=00 Prot=00 Driver=usbfs E: Ad=01(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms E: Ad=81(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms I: If#= 1 Alt= 0 #EPs= 2 Cls=03(HID ) Sub=00 Prot=00 Driver=usbhid E: Ad=02(O) Atr=03(Int.) MxPS= 64 Ivl=5ms E: Ad=82(I) Atr=03(Int.) MxPS= 64 Ivl=5ms I: If#= 2 Alt= 0 #EPs= 1 Cls=02(commc) Sub=02 Prot=00 Driver=cdc_acm E: Ad=83(I) Atr=03(Int.) MxPS= 8 Ivl=255ms I: If#= 3 Alt= 0 #EPs= 2 Cls=0a(data ) Sub=00 Prot=00 Driver=cdc_acm E: Ad=04(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms E: Ad=84(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms
Beziehungsweise hier exeplarisch die Ausgabe beim Nitrokey 3A mini:
T: Bus=01 Lev=02 Prnt=02 Port=01 Cnt=01 Dev#= 26 Spd=12 MxCh= 0 D: Ver= 2.10 Cls=ef(misc ) Sub=02 Prot=01 MxPS=64 #Cfgs= 1 P: Vendor=20a0 ProdID=42b2 Rev=01.05 S: Manufacturer=Nitrokey S: Product=Nitrokey 3 C: #Ifs= 4 Cfg#= 1 Atr=80 MxPwr=100mA I: If#= 0 Alt= 0 #EPs= 2 Cls=0b(scard) Sub=00 Prot=00 Driver=usbfs E: Ad=01(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms E: Ad=81(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms I: If#= 1 Alt= 0 #EPs= 2 Cls=03(HID ) Sub=00 Prot=00 Driver=usbhid E: Ad=02(O) Atr=03(Int.) MxPS= 64 Ivl=5ms E: Ad=82(I) Atr=03(Int.) MxPS= 64 Ivl=5ms I: If#= 2 Alt= 0 #EPs= 1 Cls=02(commc) Sub=02 Prot=00 Driver=cdc_acm E: Ad=83(I) Atr=03(Int.) MxPS= 8 Ivl=255ms I: If#= 3 Alt= 0 #EPs= 2 Cls=0a(data ) Sub=00 Prot=00 Driver=cdc_acm E: Ad=03(O) Atr=02(Bulk) MxPS= 64 Ivl=0ms E: Ad=84(I) Atr=02(Bulk) MxPS= 64 Ivl=0ms
Mit dem Befehl lshw können wir uns ebenso anzeigen lassen, ob der Stick angesteckt und erkannt wird. Da der USB-Stick unter die Klasse input fällt suchen wir gezielt nach diesen Geräte-Typus.
# lshw -short -C input
H/W path Device Class Description ====================================================== /0/100/1a/1/1/2 input Nitrokey 3
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 001 Device 027: ID 20a0:42b2 Clay Logic Nitrokey
Im Syslog wird uns beim Anstecken des Sticks dies entsprechend protokolliert:
Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.462049] usb 1-1.2: new full-speed USB device number 28 using ehci-pci Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.574335] usb 1-1.2: New USB device found, idVendor=20a0, idProduct=42b2, bcdDevice= 1.05 Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.574348] usb 1-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=0 Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.574353] usb 1-1.2: Product: Nitrokey 3 Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.574356] usb 1-1.2: Manufacturer: Nitrokey Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.577711] hid-generic 0003:20A0:42B2.0014: hiddev0,hidraw0: USB HID v1.11 Device [Nitrokey Nitrokey 3] on usb-0000:00:1a.0-1.2/input1 Jul 22 11:43:25 djangos-thinkpad-x230 kernel: [26709.578121] cdc_acm 1-1.2:1.2: ttyACM3: USB ACM device Jul 22 11:43:25 djangos-thinkpad-x230 mtp-probe: checking bus 1, device 28: "/sys/devices/pci0000:00/0000:00:1a.0/usb1/1-1/1-1.2" Jul 22 11:43:25 djangos-thinkpad-x230 mtp-probe: bus: 1, device: 28 was not an MTP device Jul 22 11:43:25 djangos-thinkpad-x230 snapd[999]: hotplug.go:200: hotplug device add event ignored, enable experimental.hotplug Jul 22 11:43:25 djangos-thinkpad-x230 mtp-probe: checking bus 1, device 28: "/sys/devices/pci0000:00/0000:00:1a.0/usb1/1-1/1-1.2" Jul 22 11:43:25 djangos-thinkpad-x230 mtp-probe: bus: 1, device: 28 was not an MTP device
Paketabhängigkeiten
Für den Zugriff auf die SmartCard bzw. auf den Nitrokey Pro benötigen wir z.B. für GPG den SmartCard-Daemon scdeamon und die Bibliothek libccid welche bei Linux Mint bereits in der Basisinstallation enthalten ist und mit Hilfe der Pakets scdaemon und libccid bereitgestellt werden.
Diese Pakete installieren wir, falls diese nicht bereits im System vorhanden sind, bei Bedarf mit Hilfe von apt.
$ sudo apt install scdaemon libccid
udev-Regeln
Für den Betrieb unter Linux Mint 21.2 insbesondere beim NitroPad X230 müssen wir uns noch passende udev-Definitionen hier besorgen.
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
Zum Aktivieren unserer neuen udev-Regeldatei lassen wir diese nun erneut einlesen; hierzu verwenden wir folgenden Befehl:
# udevadm control --reload-rules
nitropy
$ nitropy
Usage: nitropy [OPTIONS] COMMAND [ARGS]... Options: --help Show this message and exit. Commands: fido2 Interact with Nitrokey FIDO2 devices, see subcommands. list List Nitrokey devices (in firmware or bootloader mode) nethsm Interact with NetHSM devices, see subcommands. nk3 Interact with Nitrokey 3 devices, see subcommands. pro Interact with Nitrokey Pro devices, see subcommands. start Interact with Nitrokey Start devices, see subcommands. storage Interact with Nitrokey Storage devices, see subcommands. version Version of pynitrokey library and tool.
$ nitropy list
Command line tool to interact with Nitrokey devices 0.4.27 :: 'Nitrokey FIDO2' keys :: 'Nitrokey Start' keys: :: 'Nitrokey 3' keys /dev/hidraw0: Nitrokey 3 762D73d13B15C4eBEFECDDA5A9FFB4AA
$ nitropy nk3
Command line tool to interact with Nitrokey devices 0.4.27 Usage: nitropy nk3 [OPTIONS] COMMAND [ARGS]... Interact with Nitrokey 3 devices, see subcommands. Options: -p, --path TEXT The path of the Nitrokey 3 device --help Show this message and exit. Commands: fetch-update Fetches a firmware update for the Nitrokey 3 and stores... list List all Nitrokey 3 devices. reboot Reboot the key. rng Generate random data on the device. test Run some tests on all connected Nitrokey 3 devices. update Update the firmware of the device using the given image. validate-update Validates the given firmware image and prints the... version Query the firmware version of the device. wink Send wink command to the device (blinks LED a few times).
$ nitropy nk3 list
Command line tool to interact with Nitrokey devices 0.4.27 :: 'Nitrokey 3' keys /dev/hidraw0: Nitrokey 3 762D73d13B15C4eBEFECDDA5A9FFB4AA
$ nitropy nk3 version
Command line tool to interact with Nitrokey devices 0.4.27 v1.4.0
$ nitropy nk3 test
Command line tool to interact with Nitrokey devices 0.4.27 Found 1 Nitrokey 3 device(s): - Nitrokey 3 at /dev/hidraw0 Running tests for Nitrokey 3 at /dev/hidraw0 [1/3] UUID query SUCCESS 762D73BEFECDDA5A9FFB4A5E2C258DBA [2/3] Firmware version query SUCCESS v1.4.0 Please press the touch button on the device ... Please press the touch button on the device ... [3/3] FIDO2 SUCCESS 3 tests, 3 successful, 0 skipped, 0 failed Summary: 1 device(s) tested, 1 successful, 0 failed
$ nitropy nk3 wink
Command line tool to interact with Nitrokey devices 0.4.27
Nitrokey App 2
Den Update der Firmware auf den jeweiligen Nitrokey nehmen wir am Besten mit Hilfe der Nitrokey App V2 vor.
Dieses Hilfsprogramm holen wir uns nun in der aktuellen Version von der GitHub-Seite mit Hilfe von wget.
$ wget https://github.com/Nitrokey/nitrokey-app2/releases/download/v2.1.2/nitrokey-app-v2.1.2-x64-linux-binary.tar.gz
Anschliessend entpacken wir das heruntergeladene tar.gz.
$ tar -zvxf nitrokey-app-v2.1.2-x64-linux-binary.tar.gz -C ~/bin/
Zu guter Letzt geben wir dem Programm noch die x-Rechte, damit wir es direkt ausführen können.
$ chmod +x ~/bin/nitrokey-app-v2.1.2-x64-linux-binary
Unter Ubuntu 22.04 LTS und auch unter Linux Mint 21.2 (Victoria) scheitert aktuell1) der Start des Programms leider noch mit der Fehlermeldung:
Traceback (most recent call last):
File "nitrokeyapp/__main__.py", line 6, in <module>
ImportError: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.36' not found (required by /tmp/_MEIENQdbd/libstdc++.so.6)
[41746] Failed to execute script '__main__' due to unhandled exception!
Daher legen wir uns kurzer Hand einfach ein kleines Start-Script an:
$ vim bin/nitrokey-app-v2
- bin/nitrokey-app-v2
#!/bin/bash export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6 ~/bin/nitrokey-app-v2.1.2-x64-linux-binary
Auch dieses Script verpassen wir nun noch die x-Rechte zum einfachen ausführen.
$ chmod +x bin/nitrokey-app-v2
Zum Starten der Nitrokey-App v2 rufen wir nun einfach das angelegte Script auf.
$ nitrokey-app-v2
Über die Auswahl der angezeigten UUID auf der linken Seite des angesteckten Nitrokey 3 kann mann dann menügeführt einen Update der Firmware vornehmen.
Der erfolgreiche Update der Firmware wird entsprechend angezeigt.
Anwendungsfälle - Software
GnuPG
Da es sich bei der Chipkarte der beiden Nitrokey 3C und 3A jeweils 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.
$ sudo apt install gpg
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 gesteuert werden.
Sollte beim Aufruf des Befehls gpg die Karte nicht sofort angesprochen werden können, einfach den Befehl nochmals ausführen:
$ gpg --card-status
gpg: selecting openpgp failed: Karte nicht vorhanden gpg: OpenPGP Karte ist nicht vorhanden: Karte nicht vorhanden
card-status
Mit der Option card-status können wir uns mit dem Befehl gpg –card-status den Kartenstatus ausgeben lassen.
$ gpg --card-status
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000421030104000F662D73BB0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: rsa2048 rsa2048 rsa2048 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none]
Die einzelnen Datenfelder haben hierbei folgende Bedeutung:
| Datenfeld | Beschreibung |
|---|---|
| Application ID | Individuelle (unique) KartenID, diese beinhaltet: ° den Kartentyp ° die Version der Spezifikation ° den Hersteller und ° die Seriennummer des Cryptosticks Diese Application ID ist einmalig und bei jeder Karte anders. |
| Version | verwendete OpenPGP Version |
| Manufacturer | Hersteller der Karte |
| Serial number | Seriennummer der Karte, die vom Hersteller vergeben wurde. |
| Name of cardholder | Vorname und Nachname des Karteninhabers ( Es sind hier derzeit nur reines ASCII erlaubt, also keine deutschen Umlaute). Dieses Feld wird von GPG nicht verwendet. |
| Language prefs | Gewählte/bevorzugte Sprache (Muttersprache) des Karteninhabers. Dieses Feld wird von GPG nicht verwendet. |
| Sex | Geschlecht des Karteninhabers.: (Männlich (M), Weiblich (F) oder Leerzeichen) |
| URL of public key | Angabe einer URL, mit der der public-key mit Hilfe des Befehls fetch unter gpg --edit-card auf die Karte geladen werden kann. |
| Login data | Bei diesem Feld kann der Account-Name des Karteninhabers abgelegt werden, der bei Anmeldeversuchen genutzt werden kann. GPG führt hier keinerlei Abgleiche zwischen diesem Namen und dem Namen der in einem Schlüssel angegeben und verwendet wird durch! |
| Signature PIN | Hier kann über die beiden Schalter zwingend und nicht zwingend eingestellt werden, ob bei jedem Signatur-Vorgang die PIN abgefragt werden soll, oder nicht. Bei der Option nicht zwingend kann GPG die PIN zwischenspeichern, solange der Nitrokey-Stick angesteckt bleibt. |
| Key attributes | Angaben über Art und Umfang der hinterlegten Schlüssel |
| Max. PIN lengths | Maximale Länge der einzelnen PINs, kann nicht verändert werden! |
| PIN retry counter | Zähler für die verbleibenden Versuche zur Eingabe der richtigen PIN. Der max. Zählwert von 3 wird bei jeder Falscheingabe um eins heruntergesetzt. Sobald die richtige Admin-PIN eingegeben wurde, wir der max. Wert von 3 wieder zurück gesetzt. Die beiden ersten Werte (von links gesehen) werden für die User-PIN verwendet. GPG stellt hierbei sicher, dass beide werde synchronisiert werden. Der zweite (mittlere) Wert wird lediglich für Besonderheiten aus dem ISO-Standard 7816 (https://de.wikipedia.org/wiki/ISO_7816) verwendet. Der dritte (rechte) Wert wird als Fehlversuchszähler für die Admin_PIN verwendet. |
| Signature counter | Zähler der generierten Signaturen bzw. Signaturvorgänge mit der KArte. Der Zähler kann nicht manipuliert werden und wird lediglich zurückgesetzt, sobald ein neuer Signature-Schlüssel erzeugt oder auf die Karte geladen wird. |
| Signature key | Signatur-Schlüssel (primärer OpenPGP-Schlüssel) |
| created | Datum und Uhrzeit an dem der Schlüssel erzeugt wurde |
| Encryption key | Entschlüsselungs-Schlüssel (Unterschlüssel des primären (Signatur-)Schlüssels. |
| created | Datum und Uhrzeit an dem der Schlüssel erzeugt wurde |
| Authentication key | Authentifizierung-Schlüssel (Unterschlüssel des primären (Signatur-)Schlüssels. |
| created | Datum und Uhrzeit an dem der Schlüssel erzeugt wurde |
| General key info | Diese primäre USer ID wird angezeigt, sobald ein entsprechender öffentlicher Schlüssel (public-key) verfügbar ist. |
card-edit
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
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000421030104000F662D73BB0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: rsa2048 rsa2048 rsa2048 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none]
User-Befehle
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 quit this menu admin show admin commands help show this help list list all available data fetch fetch the key specified in the card URL passwd menu to change or unblock the PIN verify verify the PIN and list all data unblock unblock the PIN using a Reset Code
Admin-Befehle
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 commands are allowed
gpg/card> help
quit quit this menu admin show admin commands help show this help list list all available data name change card holder's name url change URL to retrieve key fetch fetch the key specified in the card URL login change the login name lang change the language preferences sex change card holder's sex cafpr change a CA fingerprint forcesig toggle the signature force PIN flag generate generate new keys passwd menu to change or unblock the PIN verify verify the PIN and list all data unblock unblock the PIN using a Reset Code factory-reset destroy all keys and data kdf-setup setup KDF for PIN authentication key-attr change the key attribute
RSA-Schlüssel generieren
Wir wollen uns nun einen neuen PGP-Schlüssel in der SmartCard erzeugen und rufen hierzu den Befehl generate auf. Der Nitrokey 3C NFC unterstützt RSA-Schlüssellängen von 2048 und maximal von 4096.
Laut der opencard-rs2) werden folgende Algorithmen unterstützt:
- RSA-2048
- RSA-3072 (nur Schlüssel-Import, keine Schlüssel-Generierung!)
- RSA-4096 (nur Schlüssel-Import, keine Schlüssel-Generierung!)
- EcDSA und ECDH für P256
- EdDSA und ECDH für Curve25519
Mit Hinblick auf die möglichen Unsicherheiten im Bezug auf die RSA-Schlüssellänge werden wir uns später noch eingehend mit der Erstellung eines ED25519 beschäftigen.
Welche RSA-Schlüssellänge eingestellt ist, können wir mit den Befehl gpg2 –card-status erfragen; die definierten Werte finden wir dann beim Punkt Key attributes.
$ gpg2 --card-status | grep Key\ attributes
Key attributes ...: rsa2048 rsa2048 rsa2048
Bevor wir nun unseren RSA-Schlüssel erzeugen, werden wir noch die Schlüssellänge von 2048 auf 4096 abändern.
Zum Ändern der Vorgabewerte benutzen wir die Option --card-edit beim Befehl gpg2.
$ gpg2 --card-edit
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000421030104000F662D73BB0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: rsa2048 rsa2048 rsa2048 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none]
Im Admin-Bereich finden wir den Befehl key-attr mit Hilfe dessen wir die Definition des Schlüsseltyps definieren können. Wir wechseln also erst einmal in den Admin Bereich.
gpg/card> admin
Admin commands are allowed
Hier rufen wir dann den Befehl key-attr auf.
gpg/card> key-attr
Im folgenden ändern wir dann für die drei (Unterschlüssel) die Schlüssellänge der RSA-Keys von 2048 auf 4096 .
Changing card key attribute for: Signature key Please select what kind of key you want: (1) RSA (2) ECC Your selection? 1 What keysize do you want? (2048) 4096 The card will now be re-configured to generate a key of 4096 bits Changing card key attribute for: Encryption key Please select what kind of key you want: (1) RSA (2) ECC Your selection? 1 What keysize do you want? (2048) 4096 The card will now be re-configured to generate a key of 4096 bits Changing card key attribute for: Authentication key Please select what kind of key you want: (1) RSA (2) ECC Your selection? 1 What keysize do you want? (2048) 4096 The card will now be re-configured to generate a key of 4096 bits
Die Default-Admin-Pin die hier abgefragt wird, lautet 12345678.
Zum Schluss verlassen wir das Programm gpg2 mit quit.
gpg/card> quit
Fragen wir nun erneut mit den Befehl gpg2 –card-status welcher Schlüssel-Typ eingestellt ist, finden wir unsere geänderten Werte.
$ gpg2 --card-status | grep Key\ attributes
Key attributes ...: rsa4096 rsa4096 rsa4096
Nun erstellen wir uns unsere gewünschten Schlüssel auf der SmartCard der Nitrokey 3C NFC. Wie schon beim Gernerieren der RSA-Schlüssel werden wir dabei menügeführt durch eine Reihe von Standardfragen gelost, 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. Hilfreiche Informationen zur Schlüsselerzeugung auf dem Kryptostick findet man in der offiziellen Doku auf der Nitrokey Webseite.
$ gpg2 --card-edit
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000421030104000F662D73BB0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: rsa2048 rsa2048 rsa2048 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none]
Die Schlüsselgenerierung erfolgt im Admin-Menü, in welches wir nun erst einmal wechseln werden.
gpg/card> admin
Admin commands are allowed
Die Erzeugung der Schlüssel erfolgt wie immer mit dem Befehl generate.
gpg/card> generate
gpg/card> generate
Admin commands are allowed
gpg/card> generate
Make off-card backup of encryption key? (Y/n) n
Please note that the factory settings of the PINs are
PIN = '123456' Admin PIN = '12345678'
You should change them using the command --change-pin
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
GnuPG needs to construct a user ID to identify your key.
Real name: Django aka [BOfH]
Email address: secmail@nausch.org
Comment: Bastard Operator from Hell
You selected this USER-ID:
"Django aka [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
Nun wird auf der Karte der gewählte Schlüssel erzeugt.
Die Erzeugung eines Schlüssels mit einer Länge von 2048 dauert ca. 5 Minuten, also keinesfalls den Nitrokey 3C NFC abziehen oder die Generierung abbrechen! Während der Erzeugung der Schlüssel leuchtet die LED im Stick.
gpg: key 2E22436430385B49 marked as ultimately trusted
gpg: revocation certificate stored as '/home/django/.gnupg/openpgp-revocs.d/E65B2BDF79A2E2E4C28F6E062E22436430385B49.rev'
public and secret key created and signed.
gpg/card> quit
pub rsa2048 2018-11-26 [SC]
E65B2BDF79A2E2E4C28F6E062E22436430385B49
uid Django aka [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>
sub rsa2048 2018-11-26 [A]
sub rsa2048 2018-11-26 [E]
ED25519-Schlüssel generieren
In dem Artikel Nitrokey Start unterstützt elliptische Kurven (ECC) wird sehr ausführlich das Zusammenspiel des Nitrokey und ECC beschrieben.
Damit auf einem Nitrokey 3C NFC Schlüssel auf Basis elliptischer Kurven generiert werden können, muss dieser mindestens die Firmware Version 1.2 verfügen. Dies kontrolliert man am einfachsten mit Folgendem Befehl.
$ gpg2 --card-status | grep Reader
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00
Ferner muss auf dem Rechner, an dem der Stick angesteckt und administriert werden soll, GnuPG in Version 2.1.16 oder höher installiert sein. Bei Linux Mint 21.2 ist dies kein Problem da aktuell3) die Version 2.2.27 bereitgestellt wird. Bei Bedarf können wir die Version z.B. wie folgt abfragen.
$ gpg2 --version | grep gpg
gpg (GnuPG) 2.2.27
Nun werden wir uns Schlüsselpaar auf Basis elliptischer Kurven auf dem Nitrokey 3C NFC generieren. Bevor wir die eigentlichen ED25519-Schlüssel generieren können, müssen wir unseren Stick erst einmal von den vorbelegten RSA-Schlüssel auf ECC-Schlüssel umstellen.
Welcher Typ eingestellt ist können wir mit den Befehl gpg2 –card-status erfragen; die definierten Werte finden wir dann beim Punkt Key attributes.
$ gpg2 --card-status | grep Key\ attributes
Key attributes ...: rsa2048 rsa2048 rsa2048
Zum Ändern der Vorgabewerte benutzen wir die Option --card-edit beim Befehl gpg2.
$ gpg2 --card-edit
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000124010304000F762D73BE0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: rsa2048 rsa2048 rsa2048 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none] gpg/card>
Im Admin-Bereich finden wir den Befehl key-attr mit Hilfe dessen wir die Definition des Schlüsseltyps definieren können. Wir wechseln also erst einmal in den Admin Bereich.
gpg/card> admin
Admin commands are allowed
Hier rufen wir dann den Befehl key-attr auf.
gpg/card> key-attr
Im folgenden ändern wir dann für die drei (Unterschlüssel) die Schlüsselart von ECC und bei der Frage nach der elliptischer Kurve wählen wir dann die Option Curve 25519.
Changing card key attribute for: Signature key
Please select what kind of key you want:
(1) RSA
(2) ECC
Your selection? 2
Please select which elliptic curve you want:
(1) Curve 25519
(4) NIST P-384
Your selection? 1
The card will now be re-configured to generate a key of type: ed25519
Note: There is no guarantee that the card supports the requested size.
If the key generation does not succeed, please check the
documentation of your card to see what sizes are allowed.
Changing card key attribute for: Encryption key
Please select what kind of key you want:
(1) RSA
(2) ECC
Your selection? 2
Please select which elliptic curve you want:
(1) Curve 25519
(4) NIST P-384
Your selection? 1
The card will now be re-configured to generate a key of type: cv25519
Changing card key attribute for: Authentication key
Please select what kind of key you want:
(1) RSA
(2) ECC
Your selection? 2
Please select which elliptic curve you want:
(1) Curve 25519
(4) NIST P-384
Your selection? 1
The card will now be re-configured to generate a key of type: ed25519
Zum Schluss verlassen wir das Programm gpg2 mit quit.
gpg/card> quit
Fragen wir nun erneut mit den Befehl gpg2 –card-status welcher Schlüssel-Typ eingestellt ist, finden wir unsere geänderten Werte.
$ gpg2 --card-status | grep Key\ attributes
Key attributes ...: ed25519 cv25519 ed25519
Nun erstellen wir uns unsere gewünschten Schlüssel auf der SmartCard der Nitrokey 3C NFC. Wie schon beim Gernerieren der RSA-Schlüssel werden wir dabei menügeführt durch eine Reihe von Standardfragen gelost, 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.
$ gpg2 --card-edit
Reader ...........: Nitrokey Nitrokey 3 [CCID/ICCD Interface] 00 00 Application ID ...: D276000124010304000F762D73BE0000 Application type .: OpenPGP Version ..........: 3.4 Manufacturer .....: unknown Serial number ....: 762D73BE Name of cardholder: [not set] Language prefs ...: [not set] Salutation .......: URL of public key : [not set] Login data .......: [not set] Signature PIN ....: forced Key attributes ...: ed25519 cv25519 ed25519 Max. PIN lengths .: 127 127 127 PIN retry counter : 3 0 3 Signature counter : 0 KDF setting ......: off Signature key ....: [none] Encryption key....: [none] Authentication key: [none] General key info..: [none]
Die Schlüsselgenerierung erfolgt im Adminmenü, in welches wir nun erst einmal wechseln werden.
gpg/card> admin
Admin commands are allowed
Die Erzeugung der Schlüssel erfolgt wie immer mit dem Befehk generate.
gpg/card> generate
Make off-card backup of encryption key? (Y/n) n
Please note that the factory settings of the PINs are
PIN = '123456' Admin PIN = '12345678'
You should change them using the command --change-pin
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) o
invalid value
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 [BOfH]
Email address: secmail@nausch.org
Comment: Bastard Operator from Hell
You selected this USER-ID:
"Django [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
gpg: key 8A088B4A80BBD384 marked as ultimately trusted
gpg: revocation certificate stored as '/home/django/.gnupg/openpgp-revocs.d/4FEC76FF42F8B44C6903D0A88A088B4A80BBD384.rev'
public and secret key created and signed.
<code>
Fragen wir nun den Inhalt der SmartCard mit dem Befehl ''**verify**'' ab, finden wir unsere gerade erstellten Schlüssel.
gpg/card> verify
<code>Version ..........: 3.4
Manufacturer .....: unknown
Serial number ....: 762D73BE
Name of cardholder: [not set]
Language prefs ...: [not set]
Salutation .......:
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: ed25519 cv25519 ed25519
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 0 3
Signature counter : 4
KDF setting ......: off
Signature key ....: 4FEC 76FF 42F8 B44C 6903 D0A8 8A08 8B4A 80BB D384
created ....: 2023-05-13 20:29:18
Encryption key....: A413 7445 540B F65E 128C C9A1 50D1 C567 0D74 A52F
created ....: 2023-05-13 20:29:18
Authentication key: BC6A CA82 9949 01CB 5925 78A8 F64E 773E 877E 941A
created ....: 2023-05-13 20:29:18
General key info..:
pub ed25519/8A088B4A80BBD384 2023-05-13 Django [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>
sec> ed25519/8A088B4A80BBD384 created: 2023-05-13 expires: never
card-no: 000F 762D73BE
ssb> ed25519/F64E773E877E941A created: 2023-05-13 expires: never
card-no: 000F 762D73BE
ssb> cv25519/50D1C5670D74A52F created: 2023-05-13 expires: never
card-no: 000F 762D73BE
Wir verlassen nun das Programm gpg2 wieder und werden anschließend den Stick personalisieren.
gpg/card> quit
pub ed25519 2023-05-13 [SC]
4FEC76FF42F8B44C6903D0A88A088B4A80BBD384
uid Django [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>
sub ed25519 2023-05-13 [A]
sub cv25519 2023-05-13 [E]
privaten Schlüsselbund
Fragen wir nun den privaten Schlüsselbund ab, finden wir den gerade angelegten Schlüssel bzw. den zugehörigen Proxy-Eintrag mit dem Verweis auf den Kryptostick. Dazu verwenden wir den Befehl gpg2 --list-secret-key bzw. die Kurzform dieses Befehls gpg2 -K.
$ gpg2 -K
gpg: checking the trustdb
gpg: marginals needed: 3 completes needed: 1 trust model: pgp
gpg: depth: 0 valid: 3 signed: 0 trust: 0-, 0q, 0n, 0m, 0f, 3u
/home/django/.gnupg/pubring.kbx
-------------------------------
sec> ed25519 2023-05-13 [SC]
4FEC76FF42F8B44C6903D0A88A088B4A80BBD384
Card serial no. = 000F 762D73BE
uid [ultimate] Django [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>
ssb> ed25519 2023-05-13 [A]
ssb> cv25519 2023-05-13 [E]
öffentlichen Schlüsselbund
Fragen wir nun den öffentlichen Schlüsselbund ab, finden wir den gerade angelegten Schlüssel. Dazu verwenden wir den Befehl gpg2 --list-public-key bzw. die Kurzform dieses Befehls gpg2 -k.
$ gpg2 --list-public-key
/home/django/.gnupg/pubring.kbx
-------------------------------
pub ed25519 2023-05-13 [SC]
4FEC76FF42F8B44C6903D0A88A088B4A80BBD384
uid [ultimate] Django [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>
sub ed25519 2023-05-13 [A]
sub cv25519 2023-05-13 [E]
Öffentlichen Schlüssel ausgeben
Damit wir später unseren öffentlichen Schlüssel auch weitergeben oder zu einem Keyserver hoch laden, exportieren wir diesen in eine Datei.
$ gpg --export --armor secmail@nausch.org > secmail@nausch.org.pubkey
Diese Datei enthält unseren Schlüssel in ASCII-lesbarer Form.
$ cat secmail@nausch.org.pubkey
- secmail@nausch.org.pubkey
-----BEGIN PGP PUBLIC KEY BLOCK----- mDMEZF/zHhYJKwYBBAHaRw8BAQdAEOQB0s+yG70M1P9yAck5asjV1acQirjk6Bzo gYrfHgC0RERqYW5nbyBbQk9mSF0gKEJhc3RhcmQgT3BlcmF0b3IgZnJvbSBIZWxs KSA8c2VjbWFpbEBtYWlsc2VydmVyLmd1cnU+iJAEExYIADgWIQRP7Hb/Qvi0TGkD 0KiKCItKgLvThAUCZF/zHgIbAwULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRCK CItKgLvThKXPAP90D5rhiWccU9cmMM5T9RaqE1Ep4gfUctqXdt64WfsW0AEA1V8g rTprSNDUMX9Tw62Ko3JFHCiToqNrxUKqIDePHQ64MwRkX/MeFgkrBgEEAdpHDwEB B0A4swxnk2PG9J1EN7LKQaNYeLlRnTO86mGOVEe6ye/j+4h4BBgWCAAgFiEET+x2 /0L4tExpA9CoigiLSoC704QFAmRf8x4CGyAACgkQigiLSoC704RQ0QEA5AE5k4Cf 8MEquXdAJeL7h7R93SC0y0eiPRQwiTh1gaYA/2wbNV3tPWuoKo5by0cAOHq01AJL BV5HSvn1JmCg8LQLuDgEZF/zHhIKKwYBBAGXVQEFAQEHQKZsynr3A9/c85P/Fo5T QhZ6qIh8eRXfM9Lo1PWpYhcAAwEIB4h4BBgWCAAgFiEET+x2/0L4tExpA9CoigiL SoC704QFAmRf8x4CGwwACgkQigiLSoC704QD4gEAlNCgutORJhmHM4OXujuSihNM SFOruQ0p30cb136eLfoBAKoOV+jsBzixXc14c0Yg+ewgukc+4ewKF81zn7SdAJEK =Jk/+ -----END PGP PUBLIC KEY BLOCK-----
Diese Datei benötigen wir später, wenn wir den public-key im Thunterbird-Mailclient installieren wollen!
change-pin
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.
Wird die Benutzer-PIN 3x falsch eingeben, wird die Karte gesperrt und kann dann nur mit der Admin-PIN oder dem Reset-Code zurückgesetzt werden. Wenn Sie den falschen Admin-Pin dreimal eingeben, wird die Karte unbrauchbar und kann dann lediglich mit einem Factory-Reset (Verlust aller Kartendaten!) zurück gesetzt werden!
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 Nutzer 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.
Verschlüsseln und entschlüsseln
Nun werden wir kurz einmal testen, ob wir mit Hilfe der Hardware-Schlüssel-Karte eine Datei ver- und wieder entschlüsseln können.
- Zunächst legen wir uns erst einmal ein beliebiges Testdokument an.
$ date >> testdatei.txt
Die Datei hat nun folgenden Inhalt:
$ cat testdatei.txt
Sat May 13 06:25:41 PM CEST 2023
- Nun verschlüsseln wir dieses Textdokument:
$ gpg2 -o testdatei.txt.pgp -a -r django@nausch.org -e testdatei.txt
gpg: checking the trustdb gpg: marginals needed: 3 completes needed: 1 trust model: pgp gpg: depth: 0 valid: 4 signed: 0 trust: 0-, 0q, 0n, 0m, 0f, 4u
Wir haben also nun zwei Dokumente auf der Platte liegen.
$ ll testdatei.txt*
-rw-rw-r-- 1 django django 33 May 13 18:25 testdatei.txt -rw-rw-r-- 1 django django 573 May 13 18:26 testdatei.txt.pgp
Die Datei testdatei.txt.pgp können wir nun soweit nicht mehr lesen.
$ cat testdatei.txt.pgp
-----BEGIN PGP MESSAGE----- hQEMA+fq0wZY6Y4UAQf9GLHhNN5BdDZNmX6Gq3eDIVnNEnZX3fuqr/A4RVBmcZtC AQXTu0ZKdHRJztOcnu8UtBlbPCK54950xcOmH2TzpAM0+AMIsnDttdG8rykJW2/z +Rvp4D49vK4wJrn367U3slTHggK3IVGKds+MB4SDvR4FxaroorC9TeFBF/xu7Tql hV9DAmpHLfhHgLjMs6OuS2WJSTKGXL8PMQg1JuZavYaeyBP1wkDY/TCPGDolNghT UYXksbKu4HR7BTeNqtQVDg8+zrCsEpCAKQiGyftI+jerHpeXhpLxvVakQj8r074d H4h44TV4ufXB7AiIari8DcuUD1sZGb4/BxeFK4ugM9JpAWFRpE6GLonMNqOz2B/9 +ELcXqw4/pjhrPGU/3y0KszlVSo3FMEBfgvrk6hrdCqCK/rXfgBVQem5h75Q3jL3 jf5te63+BtJrphbSoY3qFK+zOMCxbnHCBS0L5BYV4YfcwNg/SXS9/mvt =U5Ad -----END PGP MESSAGE-----
- Nun entschlüsseln wir unser Dokument wieder.
$ gpg2 --decrypt testdatei.txt.pgp > testdatei-entschlüsselt.txt
gpg: encrypted with 2048-bit RSA key, ID E7EAD30658E98E14, created 2023-05-13 "Django <django@nausch.org>"Den Inhalt dieser Datei können wir nun nach erfolgter Entschlüsselung natürlich wieder lesen.
$ cat testdatei-entschlüsselt.txt
Sat May 13 06:25:41 PM CEST 2023
Signieren
Nun werden wir kurz einmal testen, ob wir mit Hilfe der Hardware-Schlüssel-Karte eine Datei signieren und die Signatur auch wieder prüfen können.
- Wir legen uns also erst einmal ein beliebiges Testdokument an.
$ date >> textdatei.txt
Die Datei hat nun folgenden Inhalt:
$ cat textdatei.txt
Sat May 13 06:35:49 PM CEST 2023
- Nun signieren wir dieses Textdokument:
$ gpg --sign textdatei.txt
gpg: detected reader `Nitrokey Nitrokey 3C NFC (FSIJ-1.2.10-43243711) 00 00' gpg: signatures created so far: 5 Please enter the PIN [sigs done: 5]
Wir haben also nun zwei Dokumente auf der Platte liegen.
$ ll textdatei.txt*
-rw-rw-r-- 1 django django 33 May 13 18:35 textdatei.txt -rw-rw-r-- 1 django django 383 May 13 18:36 textdatei.txt.gpg
Die Datei textdatei.txt.pgp können wir nun soweit nicht lesen.
$ cat textdatei.txt.pgp
��������u�� y���kL�xKR+JRKR3�J���=���% ��� �� fVƦV&� � ή�! FF�\���, � �b�,O��4k3����|f,+�.N���i��u %u^ȼ.)2)�ͤ�����f\�7 �j���� f�G�*�����>_�q��*o]��9'���w����.��|�����J��y'��H�l�.�Z���a� ����цi�����\ʝ�l΄Y�-���}�vqR����M"�Z��]�.�>5��o[�+��?���v������V��Y�K��� D�E�"� �<�SU�`�z�����K��r5�4 9�.��j2�$�K+�;qW�3���/a��w�Lg�N��;�c+���^�z��Die Datei beinhaltet die Signatur zu unserer Datei, also entsprechender Zahlensalat.
$ file textdatei.txt.gpgtextdatei.txt.gpg: data
Dieses Vorgehen macht jedoch nur Sinn, wenn mit der Option
--encryptgleichzeitig die Datei verschlüsselt werden soll. Wir signieren nun die Datei mit dem privat-key und verschlüsseln die Datei mit dem public-key unseres eigenen Schlüssels auf dem Nitrokey 3C NFC. So kann die Datei nur von uns selbst wieder aufgemacht werden, sofern man im Besitz des Nitrokey 3C NFC und der zugehörigen PIN ist!$ gpg --encrypt --sign -r secmail@nausch.org textdatei.txt
gpg: detected reader `Nitrokey Nitrokey 3CNFC (FSIJ-1.2.10-43243711) 00 00' gpg: signatures created so far: 8 Please enter the PIN [sigs done: 8]
Wir haben nunmehr eine neue verschlüsselte und signierte Datei.
$ file textdatei.txt.gpgtextdatei.txt.gpg: PGP RSA encrypted session key - keyid: E7EAD306 58E98E14 RSA (Encrypt or Sign) 2048b .
Im nun folgendem Beispiel signieren wir unsere Datei und konvertieren sie so, dass wir sie einfach per eMail verschicken können. Hierzu nutzen wir die Option
--armor.$ gpg --sign --armor textdatei.txt
gpg: detected reader `Nitrokey Nitrokey 3C NFC (FSIJ-1.2.10-43243711) 00 00' gpg: signatures created so far: 9 Please enter the PIN [sigs done: 9]
Nun können wir uns die erstellte signierte Datei ansehen.
$ cat textdatei.txt.asc
-----BEGIN PGP MESSAGE----- owGbwMvMwMHodeDVCnmP9POMa0ySeEtSK0pSEktSM/VKgIz4vd+CE0sUfBMrFQyN FQzMrIxNrUwsFQJ8FZxdg0MUjAyMjLk6GY1ZGBg5GGTFFFmetK9p1ma28W85+vkq zFhWJpAxDFycAjCRB94cDPvZpr5pP26SIV+TsFxoAvOXFSd2KnyVmtVfeepx8rLH Wk0nTuXMenX7D2/7htilogHtpkcExK97Mm50e5Sjss7jz2bVP7xu2Uyb7p+T9H3o PDfycH/WAgU1LqGvdgxFG6ZtfGHoqb259wPDi5eV1160SH69/SM5t5d3wY0M4Zqb 93zEz4UxN1mtm/Njnn2SY/Xb/VY3fq+eNaFYbGdvyvTutvBlzXN69evv2lxfuDrc 5npJrsZpfteyuhP/Tm6wkHue46Dj53JmZ1Voz8KHRUJ1s7UnM/6ecnEB++VYw17e mdc09kzSlotkCFOSFul9IFy6e1brMaNb9+1Zf0+0Nnbr52wN/SiYc35KhbCmMgA= =qGsv -----END PGP MESSAGE-----
Soll die Originaldatei zusammen mit der Signatur in der erzeugten Datei stehen, so verwendet man die Option
–-clearsign.$ gpg --clearsign --armor textdatei.txt
Die erzeugte Testdatei.asc enthält dann sowohl den Originaltext, wie auch die Dateisignatur:
$ cat textdatei.txt.asc
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Sat May 13 06:35:49 PM CEST 2023 -----BEGIN PGP SIGNATURE----- iQEzBAEBCAAdFiEE5IesgysDPE+ExfPVSsDqqB9IZ88FAmRfvjYACgkQSsDqqB9I Z89a+wf9G8p8WwMI7YiOwD73qV0XmDovBd4DFc13Jm+0Rocz3W54MdGhcgsk3u0t 4cg5cqX4S4DxYIL15u9yYv5LVWlWqCiTyxUAiN7qxY42lUtR0+9w3Eizc6MuR7YX 0Va54V5o8jd/LoftibrUaEGVYcBw5/6M8jr2Pj0snYZqhXAYZVZ9lqiB+tqfaR0o AlAXEZb+xNni38wuClvqz03v0kL6+m9DTyLwmoGOUHEtaZIn7OR1XHv7W52v9bA6 rfhcY1xXERfjuNd6oe8SBGR428GZzbhw4m/SZqTUXlX0GHJVk0nsYbWAmQhHoY6G TDTH3OGzdvgSZl2vAd0KSzJ7i4+Dvg== =TCtk -----END PGP SIGNATURE-----
Mit
gpg -–verifykönnen wir die Signatur der Datei überprüfen:$ gpg --verify textdatei.txt.asc
gpg: Signature made Sat 13 May 2023 06:43:34 PM CEST gpg: using RSA key E487AC832B033C4F84C5F3D54AC0EAA81F4867CF gpg: Good signature from "Django <django@nausch.org>" [ultimate] gpg: WARNING: not a detached signature; file 'textdatei.txt' was NOT verified!Wir verändern nun zu Testzwecken den Inhalt der Testdatei, in dem wir den Text verfälschen.
$ vim textdatei.txt.asc
-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Sat May 13 06:35:49 PM CEST 2023 -----BEGIN PGP SIGNATURE----- IQEzBAEBCAAdFiEE5IesgysDPE+ExfPVSsDqqB9IZ88FAmRfvjYACgkQSsDqqB9I Z89a+wf9G8p8WwMI7YiOwD73qV0XmDovBd4DFc13Jm+0Rocz3W54MdGhcgsk3u0t 4cg5cqX4S4DxYIL15u9yYv5LVWlWqCiTyxUAiN7qxY42lUtR0+9w3Eizc6MuR7YX 0Va54V5o8jd/LoftibrUaEGVYcBw5/6M8jr2Pj0snYZqhXAYZVZ9lqiB+tqfaR0o AlAXEZb+xNni38wuClvqz03v0kL6+m9DTyLwmoGOUHEtaZIn7OR1XHv7W52v9bA6 rfhcY1xXERfjuNd6oe8SBGR428GZzbhw4m/SZqTUXlX0GHJVk0nsYbWAmQhHoY6G TDTH3OGzdvgSZl2vAd0KSzJ7i4+Dvg== =TCtk -----END PGP SIGNATURE-----
Nun überprüfen wir die Signatur der Testdatei, was natürlich postwendend als BAD signature angeprangert wird.
$ gpg --verify textdatei.txt.asc
gpg: Signature made Sat 13 May 2023 06:43:34 PM CEST gpg: using RSA key ID E487AC832B033C4F84C5F3D54AC0EAA81F4867CF gpg: BAD signature from "Django aka [BOfH] (Bastard Operator from Hell) <secmail@nausch.org>"
Nitrokey 3C NFC und Thunderbird
Nachdem wir nun unsere Schlüssel auf dem Kryptostick erstellt haben, wollen wir diesen nun verwenden um bei Thunderbird unsere elektronische Kommunikation per eMail abzusichern.
Schlüssel einem Konto zuweisen
Damit wir unser Kryptodevice unter Thunderbird nutzen können müssen wir unsere zuvor erzeugten Schlüsse unserem betreffenden Konto zuweisen. Über das Menü wählen wir den Punkt Konten-Einstellungen aus.
Beim passenden Konto wählen wir dann die Option Ende-zu-Ende-Verschlüsselung aus.
Hier wählen wir den letzten Menüpunkt Externen Schlüssel mittels GnuPG benutzen (z.B. von einer Smartcard) aus.
In dem nun angezeigten Fenster, tragen wir nun die Long-Key-ID unseres Schlüssels ein. Dazu holen wir uns die Key-ID aus unserem Krypto-Device wie folgt.
$ gpg2 --card-status | grep sec\>
sec> ed25519/8A088B4A80BBD384 created: 2023-05-13 expires: never
In diesem Beipiel haben wir also die Key-ID: 8A088B4A80BBD384. Diese tragen wir ein und klicken auf die Schaltfläche [ Schlüssel-ID Speichern ].
.
Schritt eins ist erledigt, der Schlüssel unseres Krypto-Devices ist nun Thunderbird bekannt.
.
Öffentlichen Schlüssel importieren
Damit wir unseren PGP-Schlüssel unseres Nitrokey 3C NFC zum Verschlüsseln und auch zum Signieren verwenden können, müssen wir noch den öffentlichen Schlüssel dem Thunderbird bekannt machen. Wie bereits beim Abschnitt GnuPG - Öffentlichen Schlüssel ausgeben angesprochen, holen wir uns nun noch unseren public-key aus dem Nitrokey 3C NFC und speichern diesen in eine Datei.
$ gpg --export --armor secmail@nausch.org > secmail@nausch.org.pubkey
Rechts im sog. „Hamburger-Menü“ finden wir den Auswahlpunkt Extras.
.
Dieses wählen wir aus und klicken dann als nächstes auf den Menüpunkt OpenPGP-Schlüssel verwalten.
Unter dem Menüpunkt Datei wählen wir nun Öffentliche(n) Schlüssel aus Datei importieren aus.
Wir wählen unsere zuvor exportierte Schlüsseldatei mit dem öffentlichen Schlüssel aus und wählen die Option Akzeptiert (nicht verifiziert) aus und klicken auf die Schaltfläche [ Importieren ].
Bevor wir nun den Import mit einem Klick auf die Schaltfläche [ OK ] abschliessen, bearbeiten wir noch die Schlüsselakzeptanz, in dem wir den blau hinterlegten Link Details anzeigen und Schlüsselakzeptanz verwalten an.
Da wir ja unseren Schlüssel selbst aus dem Nitrokey 3C NFC exportiert und im Thunderbird importiert hatten, spricht nichts dagegen, diesem Schlüssel das entsprechende Vertrauen auszusprechen. Natürlich prüfen wir hier auch den entsprechenden Fingerprint, des Kryptodevices und vergleichen diesen mit der Angabe im Fenster.
$ gpg2 --card-status | grep Signature\ key
Signature key ....: 4FEC 76FF 42F8 B44C 6903 D0A8 8A08 8B4A 80BB D384
Stimmen die Daten überein, wählen wir nun den Punkt Ja, ich selbst habe geprüft, dass der Schlüssel über den korrekten Fingerabdruck verfügt und klicken auf die Schaltfläche [OK ].
Unser öffentlicher Schlüssel ist im Keyring nun auch unserem MUA4) Thunderbird bekannt und wir können nun eMails signieren, verschlüsseln und auch empfangene verschlüsselte Nachrichten auch wieder entschlüsseln wie gewohnt.
Nitrokey 3C NFC und Nitrokey 3A mini und Secure Shell
Ob man in Zeiten von Überwachungsphantasten in Unternehmen und vor allem auch bei einer NSA oder BND, noch RSA-Schlüssel einsetzen kann und mag, muss natürlich jeder Admin für sich selbst entscheiden.
Der Sicherheitsguru Bruce Schneier hat in seinem Blog hierzu eine eindeutige Aussage getätigt:
„On the crypto bits in your guardian piece, I found especially interesting that you suggest classic discrete log crypto over ecc. I want to ask if you could elaborate more on that.“ I no longer trust the constants. I believe the NSA has manipulated them through their relationships with industry.
EED25519 ist ein Elliptic Curve Signature Schema, welches beste Sicherheit bei vertretbaren Aufwand verspricht, als ECDSA oder DSA dies der Fall ist. Zur Auswahl sicherer kryptografischer Kurven bei der Elliptic-Curve Cryptography findet man auf der Seite hier hilfreiche Erklärungen und eine Gegenüberstellung der möglichen verschiedenen Alternativen.
Auf RSA Schlüssel muss man aber nicht mehr zwingend zurückgreifen, stehen doch aktuellere und zeitgemässere Cipher, MACs, Schlüssel Typen und Key Exchange Algorithmen zur Verfügung. Als Alternative zu einem RSA-Keys haben wir uns bereits im Abschnitt Nitrokey 3 und GnuPG - ED25519-Schlüssel generieren Schlüsselmaterial auf Basis elliptischer Kurven erstellt, unter anderem auch einen Authentication Key erstellt. Diesen Schlüssel wollen wir nun auch zur Serveradministration verwenden.
SSH Client vorbereiten
Damit wir beim Verbindungsaufbau auf den Authentication Key zugreifen können, müssen wir unseren Client entsprechend vorbereiten.
Hierzu aktivieren wir zunächst die Option enable-ssh-support in der Konfigurationsdatei ~/.gnupg/gpg-agent.conf
des GPG-Agenten.
$ vim ~/.gnupg/gpg-agent.conf
- ~/.gnupg/gpg-agent.conf
# File re-created by pEp # See backup in '/home/django/.gnupg/gpg-agent.conf.1.pep.bkp' # File re-created by pEp # See backup in '/home/django/.gnupg/gpg-agent.conf.0.pep.bkp' default-cache-ttl 300 max-cache-ttl 999999 # Django : 2023-07-21 # SSH-Unterstützung beim gnupg-agent aktiviert enable-ssh-support
Anschließend müssen wir noch die Datei ~/.bashrc erweitern, damit der SSH_AUTH_SOCK für den Zugriff des SSH-Schlüssels auf dem Nitrokey Start genutzt werden kann.
$ vim ~/.bashrc
- ~/.bashrc
# .bashrc # Source global definitions if [ -f /etc/bashrc ]; then . /etc/bashrc fi # User specific environment PATH="$HOME/.local/bin:$HOME/bin:$PATH" export PATH # Uncomment the following line if you don't like systemctl's auto-paging feature: # export SYSTEMD_PAGER= # User specific aliases and functions # Django : 2023-07-27 # Definition des SSH_AUTH_SOCK für den Zugriff des SSH-Schlüssels auf dem Nitrokey Start unset SSH_AGENT_PID if [ "${gnupg_SSH_AUTH_SOCK_by:-0}" -ne $$ ]; then export SSH_AUTH_SOCK="$(gpgconf --list-dirs agent-ssh-socket)" fi
Damit unsere Änderungen aktiv werden, müssen wir nun zum Schluss noch den pgp-agent restarten bzw. einen Neustart des Clients erwirken. Der Einfachheit halber für den pragmatischen weg und melden uns einmal von unserer X-Session an unserem Clientrechner ab und wieder an!
Public-Key des ED25519 SSH exportieren
Für den Zugriff auf unser Ziel-System mit Hilfe der SSH benötigen wir noch den öffentlichen Schlüssel unseres Authentication Keys, den wir nun exportieren werden. Zunächst besorgen wir uns die betreffende Schlüsselkennung des Autentication Keys, genauer gesagt die 4 letzten Zahlenreihen des nachfolgenden Aufrufs.
$ gpg2 --card-status | grep Authentication\ key
Authentication key: 52A9 FF83 7DAF 9A77 7914 C5B1 B2DC 29E1 28F5 834D
In diesem Konfigurationsbeispiel ist die Schlüssel-ID des Autentication Keys also die Nummer 52A9FF837DAF9A777914C5B1B2DC29E128F5834D.
Nun exportieren wir den öffentlichen Schlüssel und schreiben diesen in eine separate Datei.
$ keyid=$(gpg2 --card-status | grep Authentication\ key | sed 's/ //g' | sed 's/^.\{18\}//g') ; \
gpg2 --export-ssh-key $keyid >> ~/.ssh/$keyid.ssh.pubkey
Der Öffentliche Schlüssel in diesen Konfigurationsbeispiel lautet also:
$ cat .ssh/52A9FF837DAF9A777914C5B1B2DC29E128F5834D.ssh.pubkey
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJA+NwP2KxzqkrhKxi6JDRDUyE/ofPtiWwOb0ZjbQJW7 openpgp:0xF32A76AE
Diesen Schlüssel kopieren wir nun auf das entsprechende Zielsystem an Ort und Stelle ~/.ssh/authorized_keys.
$ scp ~/.ssh/52A9FF837DAF9A777914C5B1B2DC29E128F5834D.ssh.pubkey zielhost.dmz.nausch.org: && \ ssh zielhost.dmz.nausch.org 'cat authorized_keys >> ~/.ssh/authorized_keys'
Das Kopieren des Public-Keys auf unseren Zielhost mit Anpassen der Dateiberechtigungen kann man natürlich auch einfacher vornehmen. Man benutzt hierzu einfach den Befehl ssh-copy-id aus dem Paket openssh-clients.
- ed25519-Key
$ ssh-copy-id -i ~/.ssh/52A9FF837DAF9A777914C5B1B2DC29E128F5834D.ssh.pubkey testhost.intra.nausch.org
Mit der Angabe von ~/.ssh/id_ed25519_dmz kopiert dann der Befehl ssh-copy-id den zugehörigen öffentlichen Schlüssel auf den Zielhost testhost.intra.nausch.org.
SSH-Verbindung aufbauen
Nun können wir wie gewohnt eine Verbindung zu unserem entfernten System aufbauen.
$ ssh zielhost.dmz.nausch.org
Da der SSH-Key zur Authentication nicht im Dateisystem liegt, sondern auf der SmartCard des Nitrokey werden wir nun nach der User-PIN gefragt, damit auf den privaten Schlüssel der Karte zugegriffen werden kann.
Der entsperrte Schlüssel der SmartCard des Nitrokey Start wird nur für den Verbindungsaufbau zum Zielsystem verwendet. Bei jedem erneuten SSH-Verbindung müssen wir erneut bei angestecktem Nitrokey Start die PIN Nummer zum Entsperren eingeben!
Web(-server)-Anwendung
Browser
Verwenden wir den Browser Google Chrome bzw. Chromium müssen wir nichts besonderes unternehmen, da diese bereits bestens vorbereitet sind. Auch beim Browser Firefox 78.0.2esr (64-bit) bedarf es keiner gesonderten Konfiguration mehr. Im Zweifelsfall kann man sich aber auch vergewissern, ob die Option hier richtig gesetzt ist.
Im Zweifelsfall geben wir also in der Adresszeile about:config ein und suchen dann nach der Option u2f.
Mit einem Doppelklick würden wir die Option aktivieren indem wir den Parameter auf auf true setzen..
Nextcloud
Vorbereitende Arbeiten
Bevor wir unseren Nitrokey 3C NFC als zusätzliches Authentifizierungs-Gerät verwenden können, sind noch ein paar vorbereitende Arbeiten notwendig. So benötigen wir zum einen eine entsprechende Erweiterung für die Nutzung der Zweifaktorauthentifizierung und zum anderen müssen wir unseren Key anmelden und zur Sicherheit noch Backup-Codes erzeugen, falls der Nitrokey 3C NFC verloren oder defekt gehen sollte.
Zuerst installieren wir uns, angemeldet als User mit entsprechenden Admin-Rechten, das Plugin Two-Factor WebAuthn aus der Gruppe Sicherheit.
Anschliessend melden wir uns wie gewohnt mit den altbekannten Anmeldedaten unseren Benutzerkontos an unserer Nextcloud an.
Die Einrichtung unseres Nitrokey 3C NFC erfolgt über das Menü [ Einstellungen ] und Sicherheit. Hier finden wir im Abschnitt Zwei-Faktor-Authentifizierung den entsprechenden Abschnitt.
Den Hinweisen entsprechend stecken wir nun den Kryptostick an den USB-C Port des Rechners und berühren die grünbläulich leuchtende Fläche auf dem Kryptostick.
Unserem nun angemeldeten Stick verpassen wir nun noch einen sprechenden Namen und schliessen damit die Erstkonfiguration ab.
Da wir ab sofort nun unseren Nitrokey 3C NFC zum Anmelden brauchen, erzeugen wir uns nun noch entsprechende Backup-Codes, damit wir uns bei Verlust oder Defekt des Krypto-Devices noch anmelden können.
Anmelden mit zwei Faktor-Authentifizierung
Wenn wir uns nun zukünftig an unserer Cloud anmelden, werden wir wie gewohnt nach dem User und Passwort gefragt.
Nach dem Bestätigen der Daten werden wir nun gebeten unseren Nitrokey 3C NFC-Stick anzustecken und die Touch-Taste darauf zu drücken bzw. genauer gesagt zu berühren.
Nach einer Sekunde werden wir automatisch angemeldet und wir können den Stick wieder vom USB-Port abziehen.
GitHub
Im nächsten Konfigurationsbeispiel wollen wir unseren GitHub-Account mit einer Zweifaktorathentifizierungsoption mit Hilfe unseres Nitrokey 3C NFC ausstatten.
Vorbereitende Arbeiten
Das Einrichten eines zweiten Faktors ist hier ausführlich beschrieben und mit Hilfe der dort beschriebenen Vorgehen werden wir nun auch vorgehen.
Bevor wir unser Krypto-Gerät als zweiten Faktor einrichten und verwenden können, müssen wir bei GitHub zunächst Textnachricht/SMS als zweiten Faktor aktivieren. Dazu gehen wir wie folgt beschrieben vor:
- Nachdem wir uns an unserem GitHub-Konto angemeldet haben, klicken wir in der rechten oberen Ecke unseres Browserfensters auf den Menüpunkt Settings
- Links finden wir nun in den persönlichen Einstellungsmöglichkeiten die Option Account security.
- Hier aktivieren wir nun den Punkt [ Enable two-factor authentication ].
- Beim Einstellungspunkt Two-factor authentication wählen wir die Option Set up using SMS und klicken auf die Schaltfläche [ Continue ].
- Unter Authentication verification, wählen wir den Country Code unseres Landes aus und geben unsere Mobiltelefonnummer (ohne führende Null) ein und klicken anschliessend auf die Schaltfläche [ Send authentication code ].
- Den sechsstelligen Code, den wir nun als SMS auf unser Mobiltelefon gesendet bekommen tragen wir nun in das Feld Enter the six-digit code sent to your phone ein und klicken anschliessend auf die Schaltfläche [ Continue ]. Anschliessend erhalten wir die recovery codes, die es ermöglichen im Notfall, falls z.B. der Nitrokey 3C NFC verloren gehen sollte, auf unser GitHub-Konto zuzugreifen.
- Die Codes speichern wir am besten auf einem sicheren Speichergerät ab. Nun klicken wir auf die Schaltfläche [ I have saved my recovery codes ] zum Aktivieren der Zweifaktorauthentifizierung unseres Benutzerkontos.
- Zu guter Letzt melden wir uns einmal ab und erneut bei GitHub an. Nach Eingabe des Passwortes wird uns nun per SMS der Zugangscode zugeschickt den wir in das betreffende Feld eingeben.
- Nun können wir endlich unseren Nitrokey 3C NFC als zweiten Faktor einbinden. Die ggf. nötige originale Beschreibung hierzu findet sich hier. Zunächst verbinden wir unseren Krypto-Stck mit dem USB-C Port unseres Rechners. In der rechten oberen Ecke unseres Browserfensters klicken wir auf den Menüpunkt Settings.
- Links finden wir nun, wie schon zuvor bei der Einrichtung der 2FA mit Textnachrichten/SMS, in den persönlichen Einstellungsmöglichkeiten die Option Account security.
- Hier wählen wir die Option Security Keys aus in dem wir auf die Schaltfläche [ Add ] klicken.
- Unter Security keys wählen wir nun die Schaltfläche [ Register new security key ] an.
- Nun geben wir einen „sprechenden Namen“ für unseren Krypto-Stick an, damit wir es bei ggf. mehreren Geräten leichter haben, diesen zuzuordnen.
- Nach Eingabe des Namen werden wir nun gebeten unseren Nitrokey 3C NFC-Stick anzustecken bzw. die Touch-Taste darauf zu drücken bzw. genauer gesagt zu berühren.
- Wurde der Nitrokey 3C NFC erkannt, wird dies in unserem Benutzerkonto entsprechend positiv vermerkt.
Anmelden mit zwei Faktor-Authentifizierung
Wenn wir uns nun zukünftig bei GitHub anmelden, werden wir wie gewohnt nach dem User und Passwort gefragt.
Anschliessend werden wir aufgefordert den Nitrokey 2C NFC anzustecken und die Touch-Taste darauf zu drücken bzw. genauer gesagt zu berühren.
Nach dem Bestätigen der Daten werden wir nun gebeten unseren Nitrokey 3C NFC-Stick anzustecken bzw. die Touch-Taste darauf zu drücken bzw. genauer gesagt zu berühren.
Nach einer Sekunde werden wir automatisch angemeldet und wir können den Stick wieder vom USB-Port abziehen.
127.0.0.1