BeID, la carte d’identité sous Linux, part 2, le terminal

Dans la première partie, j’ai expliqué comment installer les drivers pour lire la carte d’identité électronique belge ainsi que comment l’utiliser sous Thunderbird. C’était déjà pas mal mais ça serait un peu peu si c’était tout ce que savait faire cette foutue carte, non on peut s’amuser un peu avec. C’est pour cette raison qu’on est sous Linux non ?

Ce qui est beau, c’est que pour créer cette carte, l’on a utilisé des standards. Messieurs les concepteurs de systèmes, s’il vous plait, faites ça plus souvent ! C’est tellement mieux pour l’utilisateur (et surement plus facile pour vous aussi).

Pas mal de ces astuces viennent yobi.be, une belle mine d’info même si pas toujours très à jour. Le site est malheureusement down depuis quelques jours, j’espère que c’est temporaire mais sinon on peut toujours consulter l’archive ou faire revivre la page si quelqu’un a un wiki de libre.

eidenv

On commence par une simple mais marrante (et qui peut toujours servir). Le middleware vient avec la commande eidenv (un utilitaire de gestion de carte électroniques) qui affiche à la commande ceci :

$ eidenv | recode UTF8..
BELPIC_CARDNUMBER: 123456789012
BELPIC_CHIPNUMBER: 1234567890ABCDEF1234567890ABCDEF
BELPIC_VALIDFROM: 20.06.2007
BELPIC_VALIDTILL: 20.06.2012
BELPIC_DELIVERINGMUNICIPALITY: Liege
BELPIC_NATIONALNUMBER: 00310100123
BELPIC_NAME: Teuwen
BELPIC_FIRSTNAMES: Philippe Yvon
BELPIC_INITIAL: F
BELPIC_NATIONALITY: Belge
BELPIC_BIRTHLOCATION: Liège
BELPIC_BIRTHDATE: 25 AVRIL 1991
BELPIC_SEX: M
BELPIC_NOBLECONDITION: 
BELPIC_DOCUMENTTYPE: 1
BELPIC_SPECIALSTATUS: 0
BELPIC_STREETANDNUMBER: Rue de l'OpenSource 12 /b012
BELPIC_ZIPCODE: 1050
BELPIC_MUNICIPALITY: Ixelles

Ce programme est assez faible en fonctionnalité, mais il y en a une intéressante eidenv -x prog qui va exécuter prog avec les variables d’environnement précédentes.

Si votre fichier se compose de
#!/bin/bash
echo ${BELPIC_NATIONALITY}

L’exécution va donner

$ eidenv -x test.sh 2> /dev/null 
Belge

Allez cadeau: un créateur de vCard à partir d’une carte d’identité : eid2vcard.sh.

Pour les possesseurs d’une carte d’identité électronique estonienne (sait on jamais), vous pouvez jeter un œil à eidenv --stats pour voir quelques statistiques.

PKCS

PKCS ou Public Key Cryptographic Standards est un ensemble de spécifications créées par RSA labs pour la gestions des clefs. En voici 3 :

  • PKCS#11 défini ainsi une API pour utiliser des tokens pour l’authentification. Comme Firefox et Thunderbird utilise ce standard, c’est pour cette raison que l’on peut utiliser la carte avec ces deux programmes.
  • PKCS#12 est la norme pour le stockage de clefs. Si vous aviez exporté vos clefs dans Thunderbird, elles étaient stockées dans ce format. Et c’est également ce format que demande jSignPdf pour signer un document.
  • Finalement PKCS#15 permet de s’authentifier avec un token, indépendamment du fait que PKCS#11 soit utilisé ou une autre API.

Qu’est-ce qu’on peut faire avec ça ? Commençons par installer p11-kit et opensc et puis regardons ce qu’on peut trouver comme info. Par exemple avec opensc.

$ opensc-tool --list-algorithms
Using reader with a card: ACS ACR 38U-CCID 00 00
Algorithm: rsa
Key length: 1024
Flags: padding ( pkcs1 ) hashes ( )
$ opensc-explorer 
OpenSC Explorer version 0.12.2
Using reader with a card: ACS ACR 38U-CCID 00 00
OpenSC [3F00]> random 16
00000000: A7 EE 33 78 33 05 EA A6 7C 5C 54 2D 70 DA 83 38 ..3x3...|T-p..8

La commande pkcs11-tool ne fonctionnait pas chez moi (sans doute parce qu’ils utilisaient une version un peu modifiée du protocole) mais bien pkcs15-tool. On peut par exemple avoir le contenu de la carte

$ pkcs15-tool --dump
Using reader with a card: ACS ACR 38U-CCID 00 00
PKCS#15 Card [BELPIC]:
	Version        : 0
	Serial number  : 534C494E336600296CFF278CD00B1D2E
	Manufacturer ID: (unknown)
	Flags          : PRN generation, EID compliant

PIN [Basic PIN]
	Object Flags   : [0x3], private, modifiable
	ID             : 01
	Flags          : [0x30], initialized, needs-padding
	Length         : min_len:4, max_len:12, stored_len:8
	Pad char       : 0xFF
	Reference      : 1
	Type           : bcd
	Path           : 3f00

Private RSA Key [Authentication]
	Object Flags   : [0x3], private, modifiable
	Usage          : [0x4], sign
	Access Flags   : [0x1D], sensitive, alwaysSensitive, neverExtract, local
	ModLength      : 1024
	Key ref        : 130 (0x82)
	Native         : yes
	Path           : 3f00df00
	Auth ID        : 01
	ID             : 02

Private RSA Key [Signature]
	Object Flags   : [0x3], private, modifiable
	Usage          : [0x200], nonRepudiation
	Access Flags   : [0x1D], sensitive, alwaysSensitive, neverExtract, local
	ModLength      : 1024
	Key ref        : 131 (0x83)
	Native         : yes
	Path           : 3f00df00
	Auth ID        : 01
	ID             : 03

X.509 Certificate [Authentication]
	Object Flags   : [0x3], private, modifiable
	Authority      : no
	Path           : 3f00df005038
	ID             : 02
	Encoded serial : 02 10 1000000000000A6E5CEDB27CC97A20FD

X.509 Certificate [Signature]
	Object Flags   : [0x3], private, modifiable
	Authority      : no
	Path           : 3f00df005039
	ID             : 03

On voit que la carte utilise des certificats X.509 qui est une norme pour la gestion de chiffrement à clef publique (comme OpenPGP). Sachant ça, on peut utiliser openssl pour chiffrer quelques messages.

Je vous conseille de lire les manuels des outils pkcs, il y a de nombreuses fonctionnalités (explorer le contenu de la carte pour générez des bits aléatoires par exemple), une vous sera sans doute utile…

OpenSSL

OpenSSL est vraiment un programme très puissant et il nous le montre une fois de plus. Imaginons que vous voulez signer un message à envoyé à un ami en utilisant votre carte. Voici quoi faire :

$ openssl sha1 -binary msg.txt > msg.sha1 # hash du message
$ pkcs15-crypt --key 2 --sign --pkcs1 --sha-1 --input msg.sha1 --output msg.auth.sig
Using reader with a card: ACS ACR 38U-CCID 00 00
Enter PIN [Basic PIN]:

En plus du message et du fichier .sig, votre ami a besoin de votre certificat. On l’exporte comme ceci :

$ pkcs15-tool --read-certificate 02 > mykey.pem
Using reader with a card: ACS ACR 38U-CCID 00 00

Et pour finir, votre correspondant doit vérifier la signature par rapport à la clef publique

$ openssl x509 -in mykey.pem -pubkey -noout > mykey.pub
$ openssl dgst -sha1 -verify mykey.pub -signature msg.auth.sig msg.txt
Verified OK

Bingo ? Non !

Si vous êtes un peu parano, vous vous dites, « qu’est-ce qui me garantit que le certificat envoyé avec la signature n’est pas un faux ? » En effet un attaquant aura pu créer une clef à votre nom et l’utiliser pour signer le fichier. L’avantage d’utiliser les certificats de la carte d’identité plutôt que ceux que vous avez généré et que l’on a pas besoin d’échange de mallette diplomatique, car on a une chaine de signature.

$ openssl x509 -in mykey.pem -issuer -noout
issuer= /C=BE/CN=Citizen CA/serialNumber=200801

Mon certificat a ici été signé avec le certificat citizen avec le numéro de série 200801. Allons récupérer ce certificat sur repository.eid.belgium.be.

Attention, le fichier .crt n’est pas directement exploitable, il est au format DER (pour Distinguished Encoding Rules). Vous pouvez soit utiliser l’option export de firefox (pas trouvé comment faire avec chromium) lorsque vous examinez le certificat, soit convertir ce fichier avec openssl x509 -in citizen200801.crt -inform DER -outform PEM -out citizen200801.pem. On notera au passage qu’un site qui distribue des certificats et qui est même pas foutu d’utiliser SSL, c’est un peu se foutre du monde…

Ce certificat est signé par Belgium Root CA, donc il nous le faut aussi. Il suffira de rassembler tous les certificats de la chaine (ici belgiumrca et citizen200801) dans un fichier et puis vérifier la validité de notre clef en comparant avec le CA.

$ cat belgiumrca.pem citizen200801.pem > becitizenca.pem
$ openssl verify -CAfile becitizenca.pem mykey.pem
mykey.pem: OK

Maintenant on peut dire Bingo !

Voila un article pas mal plus technique et terminalesque que le précédent mais j’espère qu’il vous a plu quand même et que tout cela vous sera utile un jour (ou à défaut, était fun…). Si jamais je trouve d’autres info intéressantes, je ferai un troisième article mais je pense qu’on a fait le tour du plus important.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *