fedora:nitrokey:start

Nitrokey Start in der Praxis unter Fedora 29

Bild: Nitrokey Start USB-Stick In diesem Kapitel befassen wir uns eingehend mit dem Nitrokey Start (Daten-/Infoblatt) unter Fedora 29. Weitere Informationen zum Nitrokey-Stick findet findet man auch hier bzw. im Support Forum.

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 Start welcher hier für einen überschaubaren Betrag von gerade mal 29€ erstanden werden kann. In dem folgenden Beitrag gehen wir auf die Verwendung unter Fedora 29 ein. Hinweise zu den Besonderheiten bei der Verwendung unter CentOS 7.x sind hier zu finden.

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

 # usb-devices
T:  Bus=02 Lev=02 Prnt=02 Port=01 Cnt=01 Dev#=  3 Spd=12  MxCh= 0
D:  Ver= 2.00 Cls=00(>ifc ) Sub=00 Prot=00 MxPS=64 #Cfgs=  1
P:  Vendor=20a0 ProdID=4211 Rev=02.00
S:  Manufacturer=Nitrokey
S:  Product=Nitrokey Start
S:  SerialNumber=FSIJ-1.2.10-43243711
C:  #Ifs= 1 Cfg#= 1 Atr=80 MxPwr=100mA
I:  If#= 0 Alt= 0 #EPs= 3 Cls=0b(scard) Sub=00 Prot=00 Driver=(none)

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

 # lsusb
Bus 002 Device 003: ID 20a0:4211 Clay Logic 

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

 # journalctl -f
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: new full-speed USB device number 3 using uhci_hcd
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: New USB device found, idVendor=20a0, idProduct=4211, bcdDevice= 2.00
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: New USB device strings: Mfr=1, Product=2, SerialNumber=3
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: Product: Nitrokey Start
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: Manufacturer: Nitrokey
Nov 26 20:03:48 lenovo-r60 kernel: usb 2-2: SerialNumber: FSIJ-1.2.10-43243711
Nov 26 20:03:48 lenovo-r60 mtp-probe[6258]: checking bus 2, device 3: "/sys/devices/pci0000:00/0000:00:1d.0/usb2/2-2"
Nov 26 20:03:48 lenovo-r60 mtp-probe[6258]: bus: 2, device: 3 was not an MTP device
Nov 26 20:03:48 lenovo-r60 mtp-probe[6265]: checking bus 2, device 3: "/sys/devices/pci0000:00/0000:00:1d.0/usb2/2-2"
Nov 26 20:03:48 lenovo-r60 mtp-probe[6265]: bus: 2, device: 3 was not an MTP device

Wer es lieber graphisch dargestellt haben will, nutzt einfach den Befehl i-nex aus dem gleichnamigen RPM-Paket.

Bild: Bildschirmausgabe von i-nex zum USB-Device Nitrokey

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

Dieses Paket installieren wir nun noch via yum.

 # dnf install gnupg2 -y
 $ gpg2 --version
gpg (GnuPG) 2.2.9
libgcrypt 1.8.3
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: /home/django/.gnupg
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Da es sich bei der Chipkarte des Nitrokey Start um eine standardkompatible OpenPGP-Karte handelt, kann der Kryptostick mit Hilfe von GnuPG verwaltet werden.

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

card-status

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

 $ gpg2 --card-status
Reader ...........: Nitrokey Nitrokey Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
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 3 3
Signature counter : 0
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 herunter gesetzt. 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 Signatur-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 Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
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 3 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

gpg/card>
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 Start unterstützt RSA-Schlüssellängen von 1024 und maximal von 2048! 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.

Erst einmal befassen wir uns mit der Erzeugung eines RSA-Schlüsselpaaares. Wir werden dabei nun menügeführt durch eine Reihe von Standardfragen geführt, welche alle relevante Daten abfragen, die zur Generierung des Hauptschlüssels wie auch der Unterschlüssel die für die Aufgaben Signatur, Verschlüsselung und Authentifizierung benötigt werden. Hilfreiche Informationen zur Schlüsselerzeugung auf dem Kryptostick findet man in der offiziellen Doku auf der Nitrokey Webseite.

 $ gpg --card-edit
 gpg/card> admin
Admin commands are allowed
 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 Start abziehen oder die Generierung abbrechen! Während der Erzeugung der Schlüssel leuchtet die rote 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 Start und ECC beschrieben.

Damit auf einem Nitrokey Start 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 mi Folgendem Befehl.

 $ gpg2 --card-status | grep Reader
Reader ...........: Nitrokey Nitrokey Start (FSIJ-1.2.10-43243711) 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 Fedora 29 ist dies kein Problem da aktuell1) die Version 2.2.9 bereitgestellt wird. Bei Bedarf können wir die Version z.B. wie folgt abfragen.

 $ gpg2 --version | grep gpg
gpg (GnuPG) 2.2.9

Nun werden wir uns Schlüsselpaar auf Basis elliptischer Kurven auf dem Nitrokey Start 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 Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
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 3 3
Signature counter : 0
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

gpg/card>

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 Start. 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 Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
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 3 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]

gpg/card> 

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) 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
gpg: key 9308FC78386863AC marked as ultimately trusted
gpg: revocation certificate stored as '/home/django/.gnupg/openpgp-revocs.d/3E61A50347B523824132EC069308FC78386863AC.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>Reader ...........: Nitrokey Nitrokey Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
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 3 3
Signature counter : 4
Signature key ....: 3E61 A503 47B5 2382 4132  EC06 9308 FC78 3868 63AC
      created ....: 2018-11-27 21:26:26
Encryption key....: FB2B D8AD 4660 EADE 0108  852D BF1E A3F7 0320 3D8A
      created ....: 2018-11-27 21:26:26
Authentication key: 9131 32BE D5AF D08E 4464  89B6 77F0 A5B2 F32A 76AE
      created ....: 2018-11-27 21:26:26
General key info..: pub  ed25519/9308FC78386863AC 2018-11-27 Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sec>  ed25519/9308FC78386863AC  created: 2018-11-27  expires: never     
                                card-no: FFFE 43243711
ssb>  ed25519/77F0A5B2F32A76AE  created: 2018-11-27  expires: never     
                                card-no: FFFE 43243711
ssb>  cv25519/BF1EA3F703203D8A  created: 2018-11-27  expires: never     
                                card-no: FFFE 43243711

Wir verlassen nun das Programm gpg2 wieder und werden anschließend den Stick personalisieren.

gpg/card> quit
pub   ed25519 2018-11-27 [SC]
      3E61A50347B523824132EC069308FC78386863AC
uid                      Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sub   ed25519 2018-11-27 [A]
sub   cv25519 2018-11-27 [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
sec>  rsa2048 2018-11-26 [SC]
      E65B2BDF79A2E2E4C28F6E062E22436430385B49
      Card serial no. = FFFE 43243711
uid           [ultimate] Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
ssb>  rsa2048 2018-11-26 [A]
ssb>  rsa2048 2018-11-26 [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.gpg
-------------------------------
pub   rsa2048 2018-11-26 [SC]
      E65B2BDF79A2E2E4C28F6E062E22436430385B49
uid           [ultimate] Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sub   rsa2048 2018-11-26 [A]
sub   rsa2048 2018-11-26 [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-----
 
mQENBFv8ZM0BCADIZ1us1KDfrl+VVZTmjgVDb9XLSJDWOCjjhngzkBNVIYpPRL9P
CVueNDD+TiWQ7HyKKnel/L3cOsyIVoOkgqyQdKUQftDf48ajhH2Y+JBYgsIkfRMP
uKNoMSyqdNSxcHc/O0NtQlVbiLG/G8Dnssb7+ANMQuruka4b56U83rDeaMVMEYKi
GwETwrEguCFMloRCeAZL3iU8t8p/r7EeIKSokxL+FNW7xjnRjq8JLE2R5/103I+s
9+2MqLoX3K1h30l8Iqc2p4cUNjItSvxcmsb5kJoKoR4050c13zcmdQ9UZ8XvvxmI
xiS8izqUwolqwhb6QFv3kgggZovG1hQDHk1NABEBAAG0SERqYW5nbyBha2EgW0JP
ZkhdIChCYXN0YXJkIE9wZXJhdG9yIGZyb20gSGVsbCkgPHNlY21haWxAbWFpbHNl
cnZlci5ndXJ1PokBTgQTAQgAOBYhBOZbK995ouLkwo9uBi4iQ2QwOFtJBQJb/GTN
AhsDBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEC4iQ2QwOFtJqFoIAIW78N3r
Y3FC+V/IWgqFQbdeLEsL2NOQCzWZEzsAG4mejHmdh0oEPNK90tv4sRxzW/fdnqIZ
UrdfW+vwWQET6sj7qhRUhkwVHFfZQ/7FCzll+DuoKLB8OvQeILXqeo2+6AsGlDQm
ySUEMU1Dg2nBnlye9uwVnQe83BNtKv4zJpVPu7vSiWpCyyIuXc9C4PZcBmFQpm82
wy88NKqWq72aUVXfMorJgRsSiP9DBG/OM++lySdjHB22y5who7680zTiy2lew220
CaOwVKwAfW7ZqV1su/VaKSaV4GeoC4LQStZhWFPe7T/oKYhWkOwhfSdE1NavUNpC
vBGNMjXqsS7JmJS5AQ0EW/xkzQEIAKsH1ePbKq4QZ+SLbCbMXnj1fAISkUX2Hmxt
v/+IJUqpZ++qneUVqNiSgHjywXjBDH0v1jQanr804PjwSXUuPYMAamL7XyjnFAYX
E6SsI8PkkP5+zbiytKNb38OsqVj74XryhZKyzxmRMtqKcG8hRsUmM98OpUR/3DRS
JzM1AADF3m4mg6vLu3JeH18u0sXUD6XNRkDSW0nqtdSM7G68wtiV+2FT37XFmeYx
rVLYXnJHGtATBhv3X5bhR/w/3Jdz9oatDFmBxBgWT9TzbZZ8ad4WX+oafGAPWa7p
OV/PBy5ya5CEbv1hVyIpTNNtxu97KZkdMs8n708x+xJro8uzwasAEQEAAYkBNgQY
AQgAIBYhBOZbK995ouLkwo9uBi4iQ2QwOFtJBQJb/GTNAhsgAAoJEC4iQ2QwOFtJ
itsIAKhd7EfJdzv2jBk//2741jmD4Qfn1pHyMtwviCCeRlp8lKnogydG3GlP/PHA
DqZAjPZjV8xFHGrK5qQpAiLCQPK5V5PM4eqTXp5BIhTrbONjMYCa4RGXGFaC2oe0
Mr3QJ/b+OfeP4BU2A3w6+tmVxd4xmWRwSixYDORaJQ7WXN4bjcMozA5K82012Jou
fVWzV3cm+f6ZATKPzWdSQ5uxPnXGT1vmUzpqRXaMRd3vKQNZcp+nOOrr9e9bX6S0
CuNsU7U/1Z2hbx/w4qcsU+T1yGcpiwjNSnPAM94WjQTkMKBELrWgVQYm8SQVtkIi
f0bIUZIL3HhK/iyUihuDGaMmduG5AQ0EW/xkzQEIAMpm1u1v7Jmqfm5MrV7ErHmk
Odpq09SfuZ9TxVsKxv2sdmZSGIXSYo28yuuzvMJYRcBpsXBfdJXTqPz6PrIvCupw
piY3CfzRu0Vh67/7cK9hfjqDw1Bo29OsBBrVg42YcvogvczK4ZTDIYJpKC+bvp7Z
cogor++jmBpgvzqjRkeGpFMe1dlQ5ImSypikYPwQrbtesDpJS/p+LWrKowHFx1S4
Gz6UoezemdnViurXIEAH2gBsuDfhonlW8O4OkbCwaaqGtPzWWBxDXCwHdt81T1aO
Pc8i/PmMaAxkQrXOGn5zC9RQbDhhDrMFEg1lZEx3O6ne+fRx5UoH4j92oYcQbs0A
EQEAAYkBNgQYAQgAIBYhBOZbK995ouLkwo9uBi4iQ2QwOFtJBQJb/GTNAhsMAAoJ
EC4iQ2QwOFtJ4JMIAJzDAz9N3QEIHAK5ifPADPbgfnwgGNJdeZacFC1jX82i8srj
aYG3DfCrRvCuRzFt4W++1FXH6VRUtsMkAOtXUpOEYTwdpCFcyg9IcIgQtwXPdzUq
Gp6XZWRhyDRuLF9pwM/Bv+KbRqHERsf143wFYsiNdDZSSqqz4ayOadJ4+3x1eZYA
+Uh1NJdNwME6KqEBRELmpndnyLl028iI4Tlf87sbYhT+JKjcEMRXCEqLdKJhDxNq
cDS7Js+gFE4YQSq4FtiXA2a8JjJGpiHRFFBDTy3ckPv0ASyjyTzgWXPWXkKp+XAG
dkn5YYBdkGUXocXtTGUPR4Aji+OapxkcLvXqfSA=
=WNYT
-----END PGP PUBLIC KEY BLOCK-----

card-edit - Stick personalisieren

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

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!

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

 $ gpg --card-edit
gpg: detected reader `Nitrokey Nitrokey Start (FSIJ-1.2.10-43243711) 00 00'
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 3 3
Signature counter : 4
Signature key ....: E65B 2BDF 79A2 E2E4 C28F  6E06 2E22 4364 3038 5B49
      created ....: 2018-11-26 21:25:33
Encryption key....: C4EA A6BD BDED B2B3 B442  C2CA E1F5 5A90 8190 28A5
      created ....: 2018-11-26 21:25:33
Authentication key: 383C 2BC4 901C 7E66 1E12  21E7 468E 5BC1 0BE8 CD42
      created ....: 2018-11-26 21:25:33
General key info..: 
pub  2048R/30385B49 2018-11-26 Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sec>  2048R/30385B49  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711
ssb>  2048R/0BE8CD42  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711
ssb>  2048R/819028A5  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711

gpg/card> 
 gpg/card> admin
Admin commands are allowed

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

 gpg/card> name
Cardholder's surname: Nausch
Cardholder's given name: Michael

Als nächstes definieren wir die Sprache des Kartenbenutzers:

 gpg/card> lang
Language preferences: de

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

 gpg/card> sex
Sex ((M)ale, (F)emale or space): m

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

 gpg/card> login
Login data (account name): django

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

 gpg/card> url
URL to retrieve public key: https://keyserver.nausch.org/pks/lookup?op=get&search=0x074ECF6150A6BFED

Somit ergeben sich folgende benutzerindividuellen Daten auf der Karte:

 gpg/card> verify 
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: Michael Nausch
Language prefs ...: de
Sex ..............: male
URL of public key : [not set]
Login data .......: django
Signature PIN ....: forced
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 3 3
Signature counter : 4
Signature key ....: E65B 2BDF 79A2 E2E4 C28F  6E06 2E22 4364 3038 5B49
      created ....: 2018-11-26 21:25:33
Encryption key....: C4EA A6BD BDED B2B3 B442  C2CA E1F5 5A90 8190 28A5
      created ....: 2018-11-26 21:25:33
Authentication key: 383C 2BC4 901C 7E66 1E12  21E7 468E 5BC1 0BE8 CD42
      created ....: 2018-11-26 21:25:33
General key info..: 
pub  2048R/30385B49 2018-11-26 Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sec>  2048R/30385B49  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711
ssb>  2048R/0BE8CD42  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711
ssb>  2048R/819028A5  created: 2018-11-26  expires: never     
                      card-no: FFFE 43243711

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

 gpg/card> quit

change-pin

WICHTIG: Unbedingt vor dem ersten Ändern der PINs ist es notwendig, erst einmal Schlüssel zu generieren bzw. zu importieren! Denn sonst schlägt das Ändern der Benutzer-PIN fehl, bzw. wird die Benutzer-PIN beim Überschreiben von Schlüsseln auf den Default-Wert von 123456 zurückgesetzt. Die Default-PIN für den Admin lautet 12345678.

Es ist sehr wichtig dass als erstes die Admin-PIN und dann erst im Anschluss die Nutzer-PIN geändert wird! Denn sonst der admin-less mode aktiviert!

Mit Hilfe des Befehls gpg --change-pin können wir 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 (Verlußt aller Kartendaten!) zurück gesetzt werden!

Ferner ist darauf zu achten, dass zunächst die Admin-PIN und erst dann die Nutzer-PIN geändert. Ansonsten wird nämlich der admin-less mode aktiviert.

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 Start an seine Mitarbeiter ausgeben, werden bestimmte Daten, wie z.B. Namen, die Public Key URL oder auch das erzeugte Schlüsselmaterial zentral vorgegeben. Da der Benutzer selbst diese Daten nicht verändern können soll, wird dieser auch nicht Kenntnis von der Admin-PIN haben. Sperrt sich nun der Mitarbeiter aus, weil er die Benutzer-PIN 3x falsch eingegeben hat, kann der Neutzer natürlich nicht die Admin-PIN eingeben, da er diese nicht kennt. Hier kommt nun der Reset-Code ins Spiel. Mit Hilfe dieses Codes kann der Benutzer nun die Benutzer-PIN zurücksetzen.

 $ gpg --change-pin
gpg: OpenPGP Karte Nr. D276000124010200FFFE432437110000 erkannt

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

Ihre Auswahl?

Wir ändern also zu erste die Admin-PIN durch Auswahl des Menüpunkts 3 aus und erst anschliessend die Benutzer-PIN mit 1. 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

gpg/card> passwd
gpg: OpenPGP card no. D276000124010200FFFE432437110000 detected

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

Your selection? 3
gpg: 3 Admin PIN attempts remaining before card is permanently locked

Please enter the Admin PIN
                 
New Admin PIN
                     
New Admin PIN
PIN changed.     

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

Your selection? 1

Please enter the PIN
           
New PIN
               
New PIN
PIN changed.     

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

Your selection? 4
gpg: 3 Admin PIN attempts remaining before card is permanently locked

Please enter the Admin PIN
                 
New Reset Code
               
New Reset Code
gpg: Reset Code is too short; minimum length is 8
Error setting the Reset Code: bad passphrase

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

Your selection? q

gpg/card> quit

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 Wir legen uns erst einmal ein beliebiges Testdokument an.
     $ cat /etc/redhat-release > testdatei.txt

    Die Date hat nun folgenden Inhalt:

     $ cat testdatei.txt
    Fedora release 29 (Twenty Nine)
  2. Nun verschlüsseln wir dieses Textdokument:
     $ gpg2 -o testdatei.txt.pgp -a -r secmail@mailserver.guru -e testdatei.txt

    Wir haben also nun zwei Dokumente auf der Platte liegen.

     $ ll testdatei.txt*
    -rw-rw-r--. 1 django django  32 Nov 26 22:56 testdatei.txt
    -rw-rw-r--. 1 django django 573 Nov 26 22:57 testdatei.txt.pgp

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

     $ cat testdatei.txt.pgp
    -----BEGIN PGP MESSAGE-----
    
    hQEMA+H1WpCBkCilAQf+MwHmDi3Q/nF+LDN4nqTqE+jILQF35lfo4WXMKnd3jCsN
    t9RctXvgd1nIBPRf/LUVrpQzsgV8sQwb1B56lL/Q+/qcP6Zqf8AGCt65mmKFD3Tr
    Vyce5sgmmA+88MiHVEsjgnIc6Gce+qx8NZ8apxhmYKJ4ZB0IRQevt9UOgv89ABGw
    Qr/8HWV4bi2HzlAGq2Zm8GaQ0t7FN9Gb+onnSOhFPbjenyksgbZrQU3Mqhpqii6Y
    wJiO8TGuDtwuIpP4OuoZngiPfzrdRR+RHDDjOwj3UYaMbJ/ib3JxW8+EPTAcQwVE
    9M44T7FAySMyqTzfSRLnT2nHIk0b75jUHB/+HTRFkdJoAQJNgBjlwT7iMT19/1L5
    INzl4ugsgDo7YLrjoIuyh5r49udNj/dV+FCxooBnFd7YtQgiu7rpTTv8DRw2BqoK
    IaSfMr8JJAHsXRDflC6Pc4H6RqxPcN8/WrOMBRenLIMXegFq6CB+/Vw=
    =mPT1
    -----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 E1F55A90819028A5, created 2018-11-26
          "Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>"

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

     $ cat testdatei-entschlüsselt.txt
    Fedora release 29 (Twenty Nine)

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. Zunächst Wir legen uns erst einmal ein beliebiges Testdokument an.
     $ date > textdatei.txt

    Die Date hat nun folgenden Inhalt:

     $ cat textdatei.txt
    Mon Nov 26 23:05:51 CET 2018
  2. Nun signieren wir dieses Textdokument:
     $ gpg --sign textdatei.txt
    gpg: detected reader `Nitrokey Nitrokey Start (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  29 Nov 26 23:05 textdatei.txt
    -rw-rw-r--. 1 django django 359 Nov 26 23:11 textdatei.txt.gpg

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

     $ cat textdatei.txt.pgp
    textdatei.txt[�o�Mon Nov 26 23:05:51 CET 2018
    �[�o�
    	."Cd08[I8~�v��qF���Sʶ��#Q�5�G�C�#?��A,�Pf��$��m�fׇVd�9Xλ,gJX��i�5�
                                                                             �<)�{��\;�f�jJ14��D�m|�mW�:�v�(4� Jt�y�G��AV\<`,Q
                                                                                                                              �b �v�©]/�$�l��/as����`I���}(`�Sb�M5�%0�<Ծ&3��*��\5��^��[�d�7W���m���'k��g��t��

    Die Datei beinhaltet die Signatur zu unserer Datei, also entsporechender 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 Start. So kann die Datei nur von uns selbst wieder aufgemacht werden, sofern man im Besitz des Nitrokey Start und der zugehörigen PIN ist!

     $ gpg --encrypt --sign -r secmail@mailserver.guru textdatei.txt
    gpg: detected reader `Nitrokey Nitrokey Start (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: 905AF5E1 A5289081 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 Start (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-----
    
    owEBYAGf/pANAwACAS4iQ2QwOFtJAawwYg10ZXh0ZGF0ZWkudHh0W/xyX01vbiBO
    b3YgMjYgMjM6MDU6NTEgQ0VUIDIwMTgKiQEcBAABAgAGBQJb/HJfAAoJEC4iQ2Qw
    OFtJYvkH/jNaM5/rub4FHA40wrvcLAmaTQ1SWby2Pq5YyLI5M8zPZoJhdJgEillb
    OlK7oYfmN8EaLm+8zAtorFtKduRZECVJPnEA9O9krKZrNO72BmaiAgS7mCu+mjjH
    93jpnPgUbSV5ODE8k6jsQBbSXnfPi5t4cLUjnL71KswQILmiUbUUr+6Ro/bU8rYV
    09XJjwLOVu/kEMHOYewoIU2IvLwyB+Ln3TDa+gTJkKvItnOUCTT58tCrOPNpnqnr
    hjHVAVygg1xRP8Il7mvklTlhJJxfxZWuI0D7zdUNWO91xCWK/DiDJ/l8+ab5kX1F
    THBhV89ASD5iF770je9cpVFDkVppxEg=
    =64ew
    -----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: SHA1
    
    Mon Nov 26 23:05:51 CET 2018
    -----BEGIN PGP SIGNATURE-----
    
    iQEcBAEBAgAGBQJb/HMpAAoJEC4iQ2QwOFtJDwsH/2FRONUkJau26Q8z8xUO5LOz
    +fVcp/e9TKCRDtkNWwGc2e4gC3bpdFNiveHkPgnM390U1HnnNFY1DJDf/eBGqIWz
    S/Fg9wMja40btUgv0FtZzNszFUslcOPiOvMWRLqe/XOpOiwaLFXCchT4x6rl2igJ
    JwGj5aB1Qb5pd6+WHGl95jyzFRueetYVbLSOukiZoNnROqN0JLb+hpb/XvpQeCTd
    9BDytAMhJ+QK2RZ+EbD9PpsmTX9nM4iaLKhCcKWv6QBQDQ6ppJ+nngh/15XbSaQu
    KN0Dc7JJbDgj8CScuOGLY/BRP4rm3qhRtnzJZQU8oMOxBCxraCXKP5gtCnOPoX8=
    =ld6o
    -----END PGP SIGNATURE-----

    Mit gpg -–verify können wir die Signatur der Datei überprüfen:

     $ gpg --verify textdatei.txt.asc
    gpg: Signature made Mon Nov 26 23:26:49 2018 CET using RSA key ID 30385B49
    gpg: Good signature from "Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>"
    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: SHA1
    
    Mon Nov 26 23:05:51 CET 2099
    -----BEGIN PGP SIGNATURE-----
    
    iQEcBAEBAgAGBQJb/HMpAAoJEC4iQ2QwOFtJDwsH/2FRONUkJau26Q8z8xUO5LOz
    +fVcp/e9TKCRDtkNWwGc2e4gC3bpdFNiveHkPgnM390U1HnnNFY1DJDf/eBGqIWz
    S/Fg9wMja40btUgv0FtZzNszFUslcOPiOvMWRLqe/XOpOiwaLFXCchT4x6rl2igJ
    JwGj5aB1Qb5pd6+WHGl95jyzFRueetYVbLSOukiZoNnROqN0JLb+hpb/XvpQeCTd
    9BDytAMhJ+QK2RZ+EbD9PpsmTX9nM4iaLKhCcKWv6QBQDQ6ppJ+nngh/15XbSaQu
    KN0Dc7JJbDgj8CScuOGLY/BRP4rm3qhRtnzJZQU8oMOxBCxraCXKP5gtCnOPoX8=
    =ld6o
    -----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 Mon Nov 26 23:26:49 2018 CET using RSA key ID 30385B49
    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 erst einmal den Schlüssel dem 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 OpenPGP-Sicherheit aus.

Bild: Thunderbird - Menüpunkt OpenPGP-Sicherheit

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

Bild: Thunderbird - Auswahl des Schlüssels auf dem Kryptostick.

eMail signieren

Nun erstellen wir eine Testnachricht und wählen die Option Signieren aus.

Bild: Thunderbird - Erstellen einer neuen Nachricht.

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

Bild: Thunderbird - PIN-Abfrgae beim Signieren und Versenden einer Nachricht.

eMail entschlüsseln

Bekommen wir nun eine verschlüsselte Nachricht, die mit dem öffentlichen Schlüssel unseres Schlüssels der sich auf dem Nitrokey Start befindet, benötigen wir natürlich zum Entschlüsseln unseren Kryptostick. Falls der Stick noch nicht angesteckt wurde, werden wir entsprechend aufgefordert dies nachzuholen.

Bild: Thunderbird - Zum Entschlüsseln einer Nachricht ist der Stick anzustecken.

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

Bild: Thunderbird - PIN-Abfrgae beim Signieren und Versenden einer Nachricht.

Haben wir die PIN richtig eingegeben, wird die entschlüsselte Nachricht angezeigt.

Bild: Thunderbird - Anzeige der entschlüsselten Nachricht

Über das Schlosssymbol in der Nachricht können wir uns Details zu den Enigmail-Sicherheitsinformationen anzeigen lassen.

Bild: Thunderbird - Anzeige der Enigmail-Sicherheitsinformationen der entschlüsselten Nachricht

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äßere 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 Start und GnuPG - ED25519-Schlüssel generieren Schlüsselmaterial auf Basis eliptischer 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 wüssen wir unseren Client entsprechend vorbereiten.

In der Konfigurationsdatei ~/.gnupg/gpg.conf setzen wir als erstes die Option use-agent.

 $ vim ~/.gnupg/gpg.conf
~/.gnupg/gpg.conf
# File re-created by pEp
# See backup in '/home/django/.gnupg/gpg.conf.1.pep.bkp'
 
# File re-created by pEp
# See backup in '/home/django/.gnupg/gpg.conf.0.pep.bkp'
 
# Created by pEpEngine
keyserver hkp://keys.gnupg.net
cert-digest-algo SHA256
no-emit-version
no-comments
personal-cipher-preferences AES AES256 AES192 CAST5
personal-digest-preferences SHA256 SHA512 SHA384 SHA224
ignore-time-conflict
allow-freeform-uid
 
# Django : 2018-12-04
#          Option use-agent für Authentication Key Nutzung des Nitrokey Start bei SSH
use-agent

Im nächsten Schritt aktivieren wir 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 : 2018-12-04
#          SSH-Unterstützung beim gnupg-agent aktiviert 
enable-ssh-support

Nun werden 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 : 2018-12-04
#          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. Wir entscheiden uns der Einfachheit halber von einen Neustart des Agenten mit Hilfe des Befehls pkill gpg-agent.

 $ pkill gpg-agent

Ein Blick in die Prozessliste zeigt, dass der Agent nicht mehr läuft.

 $ ps aux | grep gpg-agent
django    8752  0.0  0.0 215740   820 pts/1    S+   21:56   0:00 grep --color=auto gpg-agent

Nun stecken wir unseren Nitrokey Start an den USB-Port und fragen den Kartenstatus ab.

 $ gpg2 --card-status
Reader ...........: Nitrokey Nitrokey Start (FSIJ-1.2.10-43243711) 00 00
Application ID ...: D276000124010200FFFE432437110000
Version ..........: 2.0
Manufacturer .....: unmanaged S/N range
Serial number ....: 43243711
Name of cardholder: Michael Nausch
Language prefs ...: de
Sex ..............: männlich
URL of public key : http://keyserver.nausch.org/pks/lookup?op=get&search=0x9308FC78386863AC
Login data .......: django
Signature PIN ....: zwingend
Key attributes ...: ed25519 cv25519 ed25519
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 3 3
Signature counter : 15
Signature key ....: 3E61 A503 47B5 2382 4132  EC06 9308 FC78 3868 63AC
      created ....: 2018-11-27 21:26:26
Encryption key....: FB2B D8AD 4660 EADE 0108  852D BF1E A3F7 0320 3D8A
      created ....: 2018-11-27 21:26:26
Authentication key: 9131 32BE D5AF D08E 4464  89B6 77F0 A5B2 F32A 76AE
      created ....: 2018-11-27 21:26:26
General key info..: pub  ed25519/9308FC78386863AC 2018-11-27 Django aka [BOfH] (Bastard Operator from Hell) <secmail@mailserver.guru>
sec>  ed25519/9308FC78386863AC  erzeugt: 2018-11-27  verfällt: niemals   
                                Kartennummer:FFFE 43243711
ssb>  ed25519/77F0A5B2F32A76AE  erzeugt: 2018-11-27  verfällt: niemals   
                                Kartennummer:FFFE 43243711
ssb>  cv25519/BF1EA3F703203D8A  erzeugt: 2018-11-27  verfällt: niemals   
                                Kartennummer:FFFE 43243711

Ein erneuter Blick in die Prozessliste zeigt nun den neu gestarteten Agenten.

 $ ps aux | grep gpg-agent
django    8766  0.0  0.0 364724   804 ?        Ss   21:57   0:00 gpg-agent --homedir /home/django/.gnupg --use-standard-socket --daemon
django    8853  0.0  0.0 215740   828 pts/1    S+   22:00   0:00 grep --color=auto gpg-agent

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: 9131 32BE D5AF D08E 4464  89B6 77F0 A5B2 F32A 76AE

In diesem Konfigurationsbeispiel ist die Schlüssel-ID des Autentication Keys also die Nummer 77F0A5B2F32A76AE.

Nun exportieren wir den öffentlichen Schlüssel und schreiben diesen in eine separate Datei.

 $ gpg2 --export-ssh-key 77F0A5B2F32A76AE >> ~/.ssh/77F0A5B2F32A76AE.pub

Der Öffentliche Schlüssel in diesen Konfigurationsbeispiel lautet also:

 $ cat ~/.ssh/77F0A5B2F32A76AE.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJA+NwP2KzxqkrhKxi6JDRDUyE/ofPtiWwOb0ZjbQJW7 openpgp:0xF32A76AE

Diesen Schlüssel kopieren wir nun auf das entsprechende Zielsystem an Ort und Stelle ~/.ssh/authorized_keys.

 $ scp ~/.ssh/77F0A5B2F32A76AE.pub zielhost.dmz.nausch.org: && ssh zielhost.dmz.nausch.org 'cat authorized_keys >> ~/.ssh/authorized_keys'

SSH-Verbindung aufbauen

Nun können wir wie gewohnt eine Verbindung zu unserem entfernten System aufbauen, sofern der GPG-Agent am laufen ist. Wir können dazu entweder erst einmal abfragen, ob dieser gestartet wurde, mit Hilfe des folgenden Aufrufs:

 $ ps -aux | grep gpg-agent
django    3760  0.0  0.0 364724  3156 ?        Ss   18:30   0:00 gpg-agent --homedir /home/django/.gnupg --use-standard-socket --daemon. 

Oder wir fragen einfach den Karten-Status ab, was unweigerlich den Neustart des GPG-Agenten nach sich zieht.

 $ gpg2 --card-status

Nun können wir die gewünschte Verbindung zum Zielsystem 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 nun im Speicher gehalten und wir können die USB-Adapter auch so wieder abziehen.

WICHTIG:
Da wir den Schlüssel nicht aus einer Datei geladen hatten, können wir diese auch nicht mit Hilfe von ssh-add wieder entladen! Wollen wir verhindern, dass auf den im Speicher vorgehaltenen Schlüssel zugegriffen wird, müssen wir manuell den GPG-Agenten beenden.

 $ pkill gpg-agent

Anschließend lassen sich Verbindungen zu unseren Remote-Systemen erst wieder aufbauen, wenn der GPG-Agent geladen und die Karte nach Eingabe der PIN entsperrt wurde!

… coming soon!


1)
November 18
Cookies helfen bei der Bereitstellung von Inhalten. Durch die Nutzung dieser Seiten erklären Sie sich damit einverstanden, dass Cookies auf Ihrem Rechner gespeichert werden. Weitere Information
  • fedora/nitrokey/start.txt
  • Zuletzt geändert: 17.12.2018 21:46.
  • von django