Nitrokey 3C NFC und Nitrokey 3A mini in der Praxis unter Linux Mint 21.2 (Victoria)

Bild: Nitrokey 3C NFC und 3A mini USB-Stick 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.

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

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

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

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

Bild: 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.

Bild: Nitrokey App V2

Der erfolgreiche Update der Firmware wird entsprechend angezeigt.

Bild: Nitrokey App V2

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@mailserver.guru
Comment: Bastard Operator from Hell
You selected this USER-ID:
    "Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>"

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@mailserver.guru>
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@mailserver.guru
Comment: Bastard Operator from Hell
You selected this USER-ID:
    "Django [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>"

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@mailserver.guru>
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@mailserver.guru>
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@mailserver.guru>
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@mailserver.guru>
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@mailserver.guru > secmail@mailserver.guru.pubkey

Diese Datei enthält unseren Schlüssel in ASCII-lesbarer Form.

$ cat secmail@mailserver.guru.pubkey
secmail@mailserver.guru.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.

Bild: PIN-Eingabedialog beim Abändern der Benutzer-/Admin-PIN

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.

  1. 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
  2. Nun verschlüsseln wir dieses Textdokument:
     $ gpg2 -o testdatei.txt.pgp -a -r django@mailserver.guru -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-----
  3. 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@mailserver.guru>"

    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.

  1. 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
  2. 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.gpg
    textdatei.txt.gpg: data

    Dieses Vorgehen macht jedoch nur Sinn, wenn mit der Option --encrypt gleichzeitig 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@mailserver.guru 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.gpg
    textdatei.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 -–verify kö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@mailserver.guru>" [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@mailserver.guru>"

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.

Bild: Thunderbird - Menüpunkt Konten-Einstellungen

Beim passenden Konto wählen wir dann die Option Ende-zu-Ende-Verschlüsselung aus.

Bild: Thunderbird - Menüpunkt Ende-zu-Ende-Verschlüsselung

Hier wählen wir den letzten Menüpunkt Externen Schlüssel mittels GnuPG benutzen (z.B. von einer Smartcard) aus.

Bild: Thunderbird - Menüpunkt Ende-zu-Ende-Verschlüsselung

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

Bild: Thunderbird - Menüpunkt Ende-zu-Ende-Verschlüsselung.

Schritt eins ist erledigt, der Schlüssel unseres Krypto-Devices ist nun Thunderbird bekannt.

Bild: Thunderbird - Menüpunkt Ende-zu-Ende-Verschlüsselung.

Ö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@mailserver.guru > secmail@mailserver.guru.pubkey

Rechts im sog. „Hamburger-Menü“ finden wir den Auswahlpunkt Extras.

Bild: Thunderbird - Menüpunkt Extras.

Dieses wählen wir aus und klicken dann als nächstes auf den Menüpunkt OpenPGP-Schlüssel verwalten.

Bild: Thunderbird - Menüpunkt OpenPGP Schlüssel verwalten

Unter dem Menüpunkt Datei wählen wir nun Öffentliche(n) Schlüssel aus Datei importieren aus.

Bild: Thunderbird - Fenster OpenPGP Schlüssel verwalten

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

Bild: Thunderbird - Fenster OpenPGP Schlüssel verwalten

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.

Bild: Thunderbird - Fenster OpenPGP Schlüssel verwalten

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

Bild: Thunderbird - Fenster OpenPGP Schlüssel verwalten

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.

Bild: Thunderbird - Fenster OpenPGP Schlüssel verwalten

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.

Bild: PIN Abfrage beim Zugriff auf den Authentication Key der SmartCard des Nitrokeys

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!

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.

Bild: Bildschirmhardcopy Firefox "about:config"

Mit einem Doppelklick würden wir die Option aktivieren indem wir den Parameter auf auf true setzen..

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.

Bild: Nextcloud - Plugin Installation

Anschliessend melden wir uns wie gewohnt mit den altbekannten Anmeldedaten unseren Benutzerkontos an unserer Nextcloud an.

Bild: Nextcloud - Anmeldebildschirm

Die Einrichtung unseres Nitrokey 3C NFC erfolgt über das Menü [ Einstellungen ] und Sicherheit. Hier finden wir im Abschnitt Zwei-Faktor-Authentifizierung den entsprechenden Abschnitt.

Bild: Nextcloud - Sicherheits-Einstellungen - Zwei-Faktor-Authentifizierung

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.

Bild: Nextcloud - Sicherheits-Einstellungen - Zwei-Faktor-Authentifizierung

Unserem nun angemeldeten Stick verpassen wir nun noch einen sprechenden Namen und schliessen damit die Erstkonfiguration ab.

Bild: Nextcloud - Sicherheits-Einstellungen - Zwei-Faktor-Authentifizierung

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.

Bild: Nextcloud - Sicherheits-Einstellungen - Backup-Codes

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.

Bild: Bildschirmhardcopy -  Anmelden an unserer Cloud

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.

Bild: Bildschirmhardcopy -  Anmelden an unserer Cloud

Nach einer Sekunde werden wir automatisch angemeldet und wir können den Stick wieder vom USB-Port abziehen.

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:

  1. Nachdem wir uns an unserem GitHub-Konto angemeldet haben, klicken wir in der rechten oberen Ecke unseres Browserfensters auf den Menüpunkt Settings Bild: GitHub Settings-Einstellungsmenüpunkt
  2. Links finden wir nun in den persönlichen Einstellungsmöglichkeiten die Option Account security. Bild: GitHub Settings-Einstellungsmenüpunkt
  3. Hier aktivieren wir nun den Punkt [ Enable two-factor authentication ]. Bild: GitHub Einstellungsoption: Two-factor authentication
  4. Beim Einstellungspunkt Two-factor authentication wählen wir die Option Set up using SMS und klicken auf die Schaltfläche [ Continue ]. Bild: GitHub Einstellungsoption: Set up using SMS
  5. 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 ]. Bild: GitHub Einstellungsoption: Set up using SMS
  6. 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. Bild: GitHub Einstellungsoption: Set up using SMS
  7. 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. Bild: GitHub Erfolgreiche Aktivierung der SMS-2FA
  8. 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. Bild: GitHub Abfrage des per SMS zugesandten Zugangscode bei SMS-2FA
  9. 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. Bild: GitHub Settings-Einstellungsmenüpunkt
  10. 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. Bild: GitHub Settings-Einstellungsmenüpunkt
  11. Hier wählen wir die Option Security Keys aus in dem wir auf die Schaltfläche [ Add ] klicken. Bild: GitHub Hinzufügen eines Hardware-Sicherheits-Schlüssels
  12. Unter Security keys wählen wir nun die Schaltfläche [ Register new security key ] an. Bild: GitHub Hinzufügen eines Hardware-Sicherheits-Schlüssels
  13. Nun geben wir einen „sprechenden Namen“ für unseren Krypto-Stick an, damit wir es bei ggf. mehreren Geräten leichter haben, diesen zuzuordnen. Bild: GitHub Hinzufügen eines Hardware-Sicherheits-Schlüssels
  14. 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. Bild: GitHub Hinzufügen eines Hardware-Sicherheits-Schlüssels
  15. Wurde der Nitrokey 3C NFC erkannt, wird dies in unserem Benutzerkonto entsprechend positiv vermerkt. Bild: GitHub definierter Nitrokey 3C NFC als 2FA

Anmelden mit zwei Faktor-Authentifizierung

Wenn wir uns nun zukünftig bei GitHub anmelden, werden wir wie gewohnt nach dem User und Passwort gefragt.

Bild: Anmeldedialog bei GitHub

Anschliessend werden wir aufgefordert den Nitrokey 2C NFC anzustecken und die Touch-Taste darauf zu drücken bzw. genauer gesagt zu berühren.

Bild: Anmeldedialog bei GitHub

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.

Bild: Anmeldedialog bei GitHub

Nach einer Sekunde werden wir automatisch angemeldet und wir können den Stick wieder vom USB-Port abziehen.

Links


1)
Stand: Juli 2023
2)
v1.1.1 - Stand Juli 2023
3)
Mai '23
4)
Mail User Agent
Diese Website verwendet Cookies. Durch die Nutzung der Website stimmen Sie dem Speichern von Cookies auf Ihrem Computer zu. Außerdem bestätigen Sie, dass Sie unsere Datenschutzbestimmungen gelesen und verstanden haben. Wenn Sie nicht einverstanden sind, verlassen Sie die Website.Weitere Information
  • nitrokey/linuxmint/3cnfc.txt
  • Zuletzt geändert: 23.07.2023 18:27.
  • von django