Title: Découverte de la Nitrokey Pro
Category: sécurité
Tags: GPG, open source, open hardware, Nitrokey, pl-fr
Date: 2019-02-05 23:10

[La Nitrokey][l_nk] Pro est une clé USB permettant de stocker des clefs PGP de
façon sécurisée, un certificat X.509, de gérer des mots de passe de type OTP,
HOTP et contient un gestionnaire de mots de passe. Contrairement aux Yubikey,
elle est **open source** (firmware et logiciels) et **open hardware**; tout est
disponible sur un dépôt [github][l_gh_nk].

![Photo de la clé source Nitrokey]({attach}./images/NITRO_0003_d.jpg)

Dans le cadre de ma reprise d'études en Licence Pro ADSILL, j'ai décidé de
présenter ce type de clef, tester les fonctionnalités avec GnuPG et
l'identification par [certificats X.509][l_x509_w].

Je vais tenter ici de faire le tour du propriétaire, son installation sous
Archlinux et les premiers paramétrages pour la gestion de clefs PGP.

## Achat, réception et déballage

J'ai commandé deux clefs (version Pro) directement sur le site officiel. La
version deux de la clé, prenant en charge les [courbes elliptiques][l_ecc] n'est
pas disponible au moment de ma commande, j'ai contacté l'équipe via leur compte
Mastodon et ils m'ont proposé la V1, suffisante pour mes besoins.

Les clefs sont arrivées en mois de cinq jours bien emballées dans une enveloppe
protectrice.

## Installation de l'application "Officielle"

Branchement de la clef, elle apparaît directement :

```
lsusb
[...]
Bus 003 Device 004: ID 20a0:4108 Clay Logic 
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
[...]
```

Nitrokey fournit une [application open][l_nk_app] source écrite en C++ / QT pour
gérer tout ce qui touche aux mots de passe TOTP, HOTP et ceux enregistrés dans
la partie gestionnaire de mots de passes.

Il suffit de l'installer avec votre gestionnaire de paquets préféré, chez moi
avec Archinux :

```
sudo trizen -S nitrokey-app
résolution des dépendances…
recherche des conflits entre paquets…
Paquets (3) hidapi-0.8.0rc1-3  libnitrokey-3.4.1-2  nitrokey-app-1.3.2-3
Taille totale installée :  2,82 MiB
:: Procéder à l’installation ? [O/n] 
[...]
```

Puis de la lancer...

![interface Nitrokey-app]({attach}./images/nitrokey_app.png)

Dans le menu `Menu` > `Configurer` > `Changer le PIN utilisateur` et 
`Changer le PIN administrateur` il est possible de changer les codes mis par 
défaut. Il sera aussi possible de le faire avec `gpg`.

## Utiliser le stockage des clefs PGP.

Nous allons nous concentrer sur la partie **smartcard** et plus précisément le
paramétrage pour l'utiliser avec des clefs PGP.

### Choix Installation.

Il y a deux façon de faire en fonctions des besoins :

 - installer `libusb-compat` pour rendre la *smartcard* disponible en espace
     utilisateur et laisser GnuPG l'utiliser en exclusivité
 - installer `pcsclite` et `ccid` et permettre l'utilisation d'OpenSC et GnuPG
     (pksc11 et GnuPG)

Je vais ici détailler la seconde méthode.

### Installation des paquets nécessaires et configuration

Je vais suivre la documentation disponible sur le [wiki
d'Archliux][l_archlinux].

```
trizen -S opensc pcsclite ccid
résolution des dépendances…
recherche des conflits entre paquets…

Paquets (3) ccid-1.4.30-2  opensc-0.19.0-2  pcsclite-1.8.24-1

Taille totale du téléchargement :  1,20 MiB
Taille totale installée :        4,26 MiB

:: Procéder à l’installation ? [O/n] o
[...]
```

Il faut alors creer le fichier `.gnupg/scdaemon.conf` pour spécifier à gnupg
d'utiliser [pcsclite][l_pcsclite] pour l'accès à la *smartcard* avec le contenu
suivant : 

```
pcsc-driver /usr/lib/libpcsclite.so
card-timeout 5
disable-ccid
```

Il faut ensuite activer le service `pcscd` 

```
# systemctl start pcscd.service
```

Il suffit de remplacer `start` par `enable` pour que son activation soit
permanente.

#### Tester...

Après avoir insérer (ou réinsérer) la Nitrokey, on va tester le fonctionnement
avec OpenSC et GnuPG, commençons par de dernier :

```
gpg --card-status
Reader ...........: Nitrokey Nitrokey Pro (0000000000000000XXXXXXXX) 00 00
Application ID ...: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Version ..........: 2.1
Manufacturer .....: ZeitControl
Serial number ....: XXXXXXXX
Name of cardholder: [non positionné]
Language prefs ...: de
Sex ..............: non indiqué
URL of public key : [non positionné]
Login data .......: [non positionné]
Signature PIN ....: forcé
Key attributes ...: rsa2048 rsa2048 rsa2048
Max. PIN lengths .: 32 32 32
PIN retry counter : 3 0 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]
```

Passons maintenant à OpenSC :

```
opensc-tool -n
Using reader with a card: Nitrokey Nitrokey Pro (0000000000000000XXXXXX) 00 00                                                                           
Failed to connect to card: Reader in use by another application
```

Oups, ça ne s'est pas vraiment bien passé et il y a une raison : GnuPG accède à
la *smartcard* de façon exclusive pour des raisons de sécurité, ça en cause
[ici][l_secu_gpg]. Il y a deux possibilités : installer une version
[patchée][l_scdaemon_patched] de scdaemon pour l'empêcher de verrouiller l'accès
à la *smartcard* (pas tip-top question sécurité) ou couper le sifflet à scdaemon
pour laisser OpenSC y accéder. Nous allons utiliser la seconde méthode : 

```
gpgconf --kill scdaemon
```

Et là miracle tout fonctionne : 

```shell
opensc-tool -n
Using reader with a card: Nitrokey Nitrokey Pro (0000000000000000XXXXXX) 00 00
OpenPGP card v2.1 (0005 00005C17)
```

Et voilà! Ce n'est pas toujours très pratique mais fonctionnel.

### Paramétrer la carte avec GnuPG

Paramétrer la carte se fait avec l'argument `--edit-card` :

```shell
gpg --edit-card
Reader ...........: Nitrokey Nitrokey Pro [...]
[...]

gpg/carte>
```

À partir de cette invite de commande, il est possible de rentrer des commandes
pour paramétrer la clef, la commande `help` affiche l'aide. Voici une liste de
commande utiles :

 - `admin` : activer / désactiver les commandes administrateur
 - `passwd` : changer les codes PIN, que se soit administrateur ou utilisateur
 - `name`, `login`, `sex`, `lang` : changer les informations du détenteur de la
      carte.
 - `url` : adresse où est stockée la clef publique
 - `generate` : générer de nouvelles clefs.

#### Changer les codes PIN par défaut

Garder les mots de passes et codes PIN par défaut, nous allons donc tous les
changer, enfin le code PIN utilisateur et celui administrateur.

```
gpg --edit-card
[...]
gpg/carte> admin
Les commandes d'administration sont permises

gpg/carte> passwd
gpg: carte OpenPGP nº D27600012401XXXXXXXXXXXXXXXXXXXX détectée

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

Quel est votre choix ?

```

Le `reset code` vous sera demandé si vous réinitialisez le compteur d'essai de
code PIN erronés.

#### Paramétrer ses informations personnelles

A la suite des précédents changements, nous allons paramétrer les informations
personnelles sur la clef.


```
gpg/carte> name
Nom du détenteur de la carte : Turanga
Prénom du détenteur de la carte : Leela

gpg/carte> login
Données d'identification (nom du compte) : leelaturanga

gpg/carte> sex
Sexe ((M)asculin, (F)éminin ou espace) : F

gpg/carte> lang 
Préférences de langue : en
```

#### Générer une paire de clef

Maintenant que toutes les informations sont saisies, il ne reste plus qu'à
générer les clefs. Mais avant de passer aux choses sérieuses, il faut paramétrer
la taille des clefs générée : 

```
gpg/carte> key-attr 
Changing card key attribute for: Signature key
Sélectionnez le type de clef désiré :
   (1) RSA
   (2) ECC
Quel est votre choix ? 1
Quelle taille de clef désirez-vous ? (2048) 4096
La carte sera maintenant reconfigurée pour générer une clef de 4096 bits
Changing card key attribute for: Encryption key
Sélectionnez le type de clef désiré :
   (1) RSA
   (2) ECC
Quel est votre choix ? 1
Quelle taille de clef désirez-vous ? (2048) 4096
La carte sera maintenant reconfigurée pour générer une clef de 4096 bits
Changing card key attribute for: Authentication key
Sélectionnez le type de clef désiré :
   (1) RSA
   (2) ECC
Quel est votre choix ? 1
Quelle taille de clef désirez-vous ? (2048) 4096
La carte sera maintenant reconfigurée pour générer une clef de 4096 bits
```

Le passage des clefs à 4096 bits ralenti sensiblement **la génération de
celles-ci** par la Nitrokey, passant de quelques secondes à plusieurs minutes.

Il ne reste plus qu'à générer les clefs : 

```
gpg/carte> generate 
Faut-il faire une sauvegarde hors carte de la clef de chiffrement ? (O/n) o
Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0) 1m
La clef expire le jeu. 07 mars 2019 22:29:17 CET
Est-ce correct ? (o/N) o

GnuPG doit construire une identité pour identifier la clef.

Nom réel : Leela Turanga
Adresse électronique : leela.turanga@planetexpress.com
Commentaire : 
Vous avez sélectionné cette identité :
    « Leela Turanga <leela.turanga@planetexpress.com> »

Changer le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? o
De nombreux octets aléatoires doivent être générés. Vous devriez faire
autre chose (taper au clavier, déplacer la souris, utiliser les disques)
pendant la génération de nombres premiers ; cela donne au générateur de
nombres aléatoires une meilleure chance d'obtenir suffisamment d'entropie.
gpg: Remarque : sauvegarde de la clef de la carte dans « /home/lee[...] »
gpg: clef 91BF810624DD9070 marquée de confiance ultime.
gpg: revocation certificate stored as '/home/lee/.gnupg/openpgp-revocs.d/[...]
les clefs publique et secrète ont été créées et signées.
```

La sauvegarde de la clé permettra de déchiffrer les données en cas de perte,
panne ou vol de la Nitrokey. Sauvegardez la bien au chaud, avec son certificat
de révocation.

## Conclusion

Voici un petit aperçu des fonctionnalités de cette clef open source et étudié
plus en profondeur la partie PGP avec GnuPG. Dans un prochain article, nous
verrons comment importer un ensemble de clefs existante dans la Nitrokey.

[l_nk]:https://www.nitrokey.com
[l_gh_nk]:https://github.com/nitrokey
[l_x509_w]:https://fr.wikipedia.org/wiki/X.509
[l_ecc]:https://fr.wikipedia.org/wiki/Cryptographie_sur_les_courbes_elliptiques
[l_pcsclite]:https://pcsclite.apdu.fr/
[l_nk_app]:https://github.com/Nitrokey/nitrokey-app
[l_archlinux]:https://wiki.archlinux.org/index.php/GnuPG#Smartcards
[l_secu_gpg]:https://lists.gnupg.org/pipermail/gnupg-devel/2015-September/030247.html
[l_scdaemon_patched]:https://aur.archlinux.org/packages/gnupg-scdaemon-shared-access/
