add content

This commit is contained in:
Yorick Barbanneau 2019-05-14 14:50:52 +02:00
parent 93c9f1e4df
commit 4ad900bcb0
81 changed files with 3170 additions and 0 deletions

Binary file not shown.

After

Width:  |  Height:  |  Size: 114 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 89 KiB

View file

@ -0,0 +1,337 @@
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 à linstallation ? [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 à linstallation ? [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/

View file

@ -0,0 +1,85 @@
Title: Déménagement et changements techniques
Category: le blog
Tags: Dotclear, Pelican, changement
Date: 2019-02-04 1:30
Status: published
Mon blog végétait depuis pas mal de temps et mes interventions y étaient plutôt
rares. J'ai envie de reprendre un peu les publications mais Dotclear, ami fidèle
depuis pas mal d'années[^n_dc] , devenait de moins en moins plaisant à utiliser.
Profitant déménagement de l'infrastructure [Giroll][l_giroll] vers un serveur
virtuel chez [Aquilenet][l_aquilenet] et la fermeture des serveur
d'Antoine[^n_antoine], j'ai décidé de tout revoir.
## Hébergement
Ce blog est maintenant hébergé sur le serveur du collectif [giroll][l_giroll]
chez [Aquilenet][l_aquilenet].
## Au revoir dotclear, bonjour Pelican
J'y pensais depuis longtemps : passer de Dotclear à un gestionnaire de site
statique. [Pelican][l_pelican] me semble un bon choix : facile à prendre en
main, une documentation fournie et surtout un module d'import depuis Dotclear.
Le resultat obltenu par ce module n'est cependant pas parfait, j'ai bricolé un
petit script avec quelques `sed` pour corriger quelques problèmes de conversion.
```bash
#!/bin/bash
find . -type f -name "*.md" -exec sed -Ei "s/\.(.*)_m\.jpg/\1\.jpg/g" {} \;
find . -type f -name "*.md" -exec sed -i "/^:::/,+d" {} \;
find . -type f -name "*.md" -exec sed -i "/Tags:/,+2d" {} \;
find . -type f -name "*.md" -exec sed -i "s/%22//g" {} \;
find . -type f -name "*.md" -exec sed -Ei "s/\.(.*)_m\.jpg/\1\.jpg/g" {} \;
find . -type f -name "*.md" -exec sed -i "s/\\//g" {} \;
find . -type f -name "*.md" -exec sed -i "s/\[\!/\!/g" {} \;
find . -type f -name "*.md" -exec sed -ie "s/)](.*/)/" {} \;
find . -type f -name "*.md" -exec sed -ie "s/)](.*/)/" {} \;
find . -type f -name "*.md" -exec sed -ie "s|/image/" {} \;
find . -type f -name '*.md; -exec sed -ie 's|\["|\[|g' {} \;
```
Certains problèmes persistent et j'ai du vérifier quelques fichiers ci-et-là.
## Adieu commentaires
Avec un gestionnaire de site statique, il faut passer par un outil externe pour
gérer les commentaire. Beaucoup passent par Disqs mais pas question pour moi de
passer par un service privateur. Il est possible de passer par un service
auto-hébergé comme [isso][l_isso]. Pour l'instant j'ai décidé de ne pas en
mettre.
Je reste cependant disponible à la discussion sur [mastodon][l_mast]
## Repartir de zéro (ou presque)
Tout le blog a été remis à plat et je suis reparti de casi-zéro. Pour ceux qui
le connaissaient, vous constatez que beaucoup d'articles manquent à l'appel.
Pour l'instant, j'ai remis ceux jugés importants. D'autres suivront et certains
ne seront tout simplement pas intégrés.
## Choix du thème
Je suis tombé sous le charme du thème [attila][l_attila] pour Pelican. Je l'ai
tout de même modifié pour correspondre à mes attentes :
- Les polices de caractères ne sont plus chargées depuis des CDN pour des
question de vie privée des visiteurs
- J'ai augmenté la largeur du contenu
- La police pour les icônes est FontAwesome
Je prévois d'intégrer les liens vers les sites amis en pied de page, plus
d'autres bricoles...
[l_giroll]:https://giroll.org
[l_aquilenet]:https://aquilenet.fr
[l_pelican]:https://blog.getpelican.com/
[l_isso]:https://posativ.org/isso/
[l_mast]:https://toot.aquilenet.fr/@ephase
[l_attila]:https://github.com/arulrajnet/attila/
[^n_antoine]:mon ami qui hébergeait mon blog et mes courriels jusque là
[^n_dc]:12 ans pour être exact

View file

@ -0,0 +1,143 @@
Title: Utiliser Gio en ligne de commande
Category: le blog
Tags: pl-fr, GIO, fichiers, terminal
Date: 2019-04-25 1:30
Status: published
J'ai depuis quelques mois décidé de changer radicalement ma façon d'utiliser mon
ordinateur : je veux aller au plus simple, rapide et sans fioritures. Fini
l'environnement de bureau **Gnome** et bonjour utilisation plus intensive
des applications en ligne de commande ou en version *"terminal"*.
J'ai aussi choisi de me passer des services d'un gestionnaire de fichiers et
d'utiliser exclusivement mon émulateur de terminal pour gérer mon
arborescence : pour l'instant j'en suis ravi. Il y a cependant un point qui
peut très vite coincer : Un gestionnaire de fichiers moderne permet le **montage
automatique des périphériques USB** ou encore le montage facile **des ressources
réseaux** et enfin **le montage par les utilisateurs non privilégiés du
système**.
Bien sûr je ne veux pas utiliser le montage automatique, mais pour tout le reste
il est possible d'utiliser `Gio`, la librairie issu du projet Gnome et utilisée
pour les montage de périphériques de stockage.
## Commençons simple, un disque USB
Le premier cas que nous allons étudier, et le plus simple, est celui de la clé
USB. Bien entendu il fait avoir installé Gio, sur Archlinux :
```
pacman -S gvfs
```
Une fois la clé branchée il suffira de trouver le périphérique représentant
notre support dans `/dev/` et la partition que l'on veux monter avec `lsblk`
```
lsblk
sda 8:0 1 14,5G 0 disk
└─sda1 8:1 1 14,5G 0 part
nvme0n1 259:0 0 477G 0 disk
[...]
```
Dans l'exemple, je veux utiliser ma clé `/dev/sda1`
```
gio mount -d /dev/sda1
/dev/sda1 a été monté sur /run/media/ephase/MaCle
```
`-d <device>` indique le périphérique de block à monter. La commande retourne le
dossier ou le périphérique est monté.
Pour démonter le périphérique, il suffira de faire
```
gio mount -u /run/media/ephase/MaCle
```
Attention, si la commande retourne le message
`gio:file:///run/media/ephase/MaCle: Un ou plusieurs programmes empêchent
lopération de démontage.` il se pourrait que dans un de vos émulateurs de
terminal lancés le répertoire courant soit celui de votre montage (ou de ses
sous répertoires).
## Monter un dossier via ssh
La commande n'est pas très compliquée mais le point de montage est un peu moins
simple à trouver et cette fois la commande ne le retourne pas le point de
montage. Bonne nouvelle tout de même : `gio` prend en compte les fichiers
`~/.ssh/config` et sait utiliser les clefs.
```
gio mount ssh://myhost.com
Saisissez la phrase de passe de la clé SSH de myhost.com
Password:
```
Le point de montage est un sous-dossier de `/run/users/<uid>/gvfs/``<uid>`
est celui de votre utilisateur, dans le cas ci-dessus :
```
tree
/run/user/1000/gvfs
└── sftp:host=myhost.com
└── mon_dossier
```
Le démontage est simple :
```
gio mount -u ssh://myhost.com
```
La commande s'applique pour toute ressource `smb`, `nfs`, `afp`. Il faut tout de
même penser à installer les **modules gio correspondant** : `gvfs-smb`,
`gvfs-nfs` et `gvfs-afp`.
## Monter un périphérique MTP
Dernier cas étudié : le [MTP][l_mtp_w], c'est le protocole de communication
utilisé notamment par les téléphones Android. Il faut là aussi installer un
paquet pour que tout fonctionne, sous Archlinux `gvfs-mtp`. La commande est plus
complexe :
```
gio mount -li | awk -F= '{if(index($2,"mtp") == 1)system("gio mount "$2)}'
```
`gio mount -li` donne des informations détaillées sur les périphériques
disponibles. Il suffit de passer le tout à `awk`, d'utiliser le séparateur `=`
et de chercher la présence de `mtp` dans la seconde colonne et si c'est le cas
d'exécuter `gio mount`.
Cette commande réalisera un montage de **tous** les périphériques *MTP*
disponibles sans distinction, il vous faudra l'adapter en fonction de vos
besoins.
Comme pour les protocoles réseaux, la commande ne retourne rien et le point de
montage est un sous dossier de `/run/users/<uid>/gvfs`.
Pour le démontage, soit nous connaissez l'URI du périphérique (du style
`mtp://Android_ae45f6`) et il suffit de faire :
```
gio mount -u mtp://Android_ae45f6
```
Sinon il est possible de donner le point de montage à la commande `gio` :
```
gio mount -u /run/users/1000/mtp:Android_ae45f6
```
## En conclusion
Utiliser exclusivement l'émulateur de terminal pour gérer les fichiers est, de
mon point de vue, simple et bigrement efficace. Avec `gio` c'est juste parfait :
peu de dépendances, rapide et facile à utiliser. Il est aussi possible
d'utiliser [udevil][l_udevil], mais ce projet semble au point mort (pas de mise
à jour ou correction de bug depuis juillet 2017).
[l_mtp_w]:https://fr.wikipedia.org/wiki/Media_Transfer_Protocol
[l_udevil]:https://github.com/IgnorantGuru/udevil/