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
1 2 | #!/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.
