# [HOWTO] Smartcard (avec OpenSC & OpenCT)

## kwenspc

Howto SmartCard (avec OpenSC & OpenCT)

(ce howto a été réalisé en prenant une e-gate cryptoflex 32k mais il est valable aussi pour les autres cartes)

Sommaire:

1 - Introduction

2 - Description rapide d'une smartcard

3 - Installation des logiciels

4 - Premiers "tours de roues"

5 - Les outils PKCS

6 - Utiliser votre smartcard

7 - Liens 

1 - Introduction:

	L'utilisation  de clé  de  cryptage (symétrique  et/ou asymétrique)  est désormais devenue  monnaie courante. 

Rien  que dans  l'utililisation  de shells distants (avec ssh), de  sites sécurisés (http + ssl) ou de  mails 

(avec gpg par exemple),  nous nous  trouvons tous  confrontés à  gérer tant  bien que  mal nos paires de clés 

et tout ce qui va avec.

	Depuis  quelques temps déjà  (oui ce  n'est pas  nouveau) il  existe des smartcards spécialisées dans le 

stockage de paires de clés et de certificats. La principale raison  de ces  cartes est  que la clé  privée 

(donc  la clé  la plus sensible!) peut  être stockée sans  pour autant pouvoir  être lue. C'est  à dire qu'une fois

la clé privée  installée (générée ou copiée puis supprimée) personne n'est en mesure  de la récupérer. 

Comme le code d'une  carte bancaire en quelque sorte.  Qui  plus  est  l'accès  à   ces  données  est  protégé  

par  des  codes (PIN). L'autre avantage est  bien sûr de se balader avec ses  clés partout où on veut.

	Sous Linux et plus  particulièrement sous notre distribution préférée le support de ce type  de carte est 

plutôt bien suivi. Je  vous invite donc à faire un  petit  tour de  la  question.  Nous  verrons l'installation,  

les  commandes basiques et enfin  l'utilisation proprement dite dans ssh,  firefox, les clients mails etc...

2 - Description rapide d'une smartcard:

	Il existe  2 types de  smartcards: 

- les  wafer-like qui  sont  comme des  cartes  de téléphone  et nécéssitent  un lecteur permettant de les y 

insérer pour les lire

- les sim-like qui ressemble en tout point  à des cartes sim et qui peuvent être lues sur  les lecteurs "normaux"

(wafer-like)  ou de petits  lecteurs (comme les e-gate) ce qui les rends d'ailleurs très attrayantes vu leur taille.

	Ces cartes intègrent toutes le  support PKCS compatible pour le stockage de  données sensibles  

(version #11  et/ou #15).   L'intégrité de  la  carte est protégée par  un code :  le Security Officer  Pin ou SO  Pin. 

Ce code,  si bloqué parce qu'on l'a mal tappé 3 fois, peut-être  débloqué par un SO Puk (si il y en a un). Le SO Pin 

sert à insérer  de nouvelles données.  Ensuite vous avez les User Pin qui protège  une structure de donnée respective 

(paire  de clé et certificat, voire data object).  Ces  User Pin sont limités en nombres (4  sur les e-gate par exemple). 

Vous êtes  obligés d'en créer un pour chaque  structure de donnée.  Si vous avez  2 paires de clés  à mettre sur la  

carte vous aurez besoin  de 2 User Pin, bien entendu rien ne vous empèche d'avoir le même code pour ces User Pin.

	Si quelqu'un vient  à vous voler votre smartcard -  s'il ne trouve aucun pin, ce qui semble plus que probable - 

il pourra cependant la réuitiliser en la réinitialisant  complètement.  En  tout  cas  c'est possibles  sur  les  e-gate:

n'importe  qui  peut tout  effacer  pour  réinitialiser  un nouveau  SO  Pin/Puk etc...Enfin du moment que personne 

ne peut lire vos données c'est le principal!

Sinon ces cartes intègrent le contrôleur USB (v 1.1) en interne.

(Je ne sais si certaines cartes intègrent un contrôleur USB 2.0, il me semble que non.)

3 - Installation des logiciels:

parametrer les USE : rajoutez le use "smartcard" dans motre make.conf

Installer OpenSC:

	C'est la  librairie de base  pour accéder aux smartcard  supportées sous Linux La version "stable" incluse 

dans portage est suffisante.

```
 

emerge dev-libs/opensc 

```

Il n'y a rien à configurer, en principe tout fonctionne bien.

Installer OpenCT:

	OpenCT apporte  un driver  pour certaines carte  (pas toutes,  il existe aussi le projet m.u.s.c.l.e mais je n'ai pas testé)

	Il faut tout  d'abord parametrer portage pour qu'il  utilise la dernière version 0.6.4 car les anciennes versions  

ne sont pas compatible avec les e-gate par exemple...(puis quelques bugs ont été corrigés)

```
 

echo dev-libs/openct ~x86 >> /etc/portage/package.keywords 

```

Ensuite :

```
 

emerge dev-libs/openct 

```

Démarrez le service openct

```
 

/etc/init.d/openct start 

```

	Là encore rien  est à configurer pour que ça  tourne.  Faites juste ceci si vous savez que vous allez utiliser 

les smartcard de manière régulière :

```
 

rc-update add openct default 

```

4 - Premiers "tours de roues":

	Branchez votre lecteur avec sa smartcard sur un port usb.

	Alors soit vous utilisez openct-tool soit opensc-tool. Je vous conseille opensc-tool.  Les outils openct ne sont  

qu'une copie des outils opensc et comme il  y a  une compatibilité  étroite  entre les  deux, opensc  peut détecter  des

lecteurs géré par openct (qui est un driver en fait)

	D'ailleurs  vous pouvez  d'hors  et déjà  connaître les  lecteurs/cartes nativement gérées par opensc en 

tappant la commande:

```
 

opensc-tool -D 

```

ce qui vous donne :

Configured card drivers: 

etoken           Siemens CardOS 

flex		    Schlumberger Multiflex/Cryptoflex 

cyberflex        Schlumberger Cyberflex

gpk              Gemplus GPK driver 

miocos           MioCOS 1.1 cards

mcrd             MICARDO 2.1 

setcos           Setec smartcards 

starcos	    driver for STARCOS SPK 2.3 cards 

tcos             TCOS 2.0 cards 

openpgp	    OpenPGP Card 

jcop             JCOP cards with BlueZ PKCS#15 applet

oberthur         Oberthur AuthentIC.v2/CosmopolIC.v4 

emv              EMV compatible cards 

default          Default driver for unknown cards 

voici les cartes dont openct fourni le support:

generic USB CCID driver 

Towitoko readers and compatibles

Schlumberger/Axalto e-gate tokens  <-- celle que j'ai utilisé 

Aladdin eToken PRO 

Rainbow iKey 3000  

	Il peut  en gérer d'autres  mais ces derniers  n'ont pas subis  tout les tests de compatibilité et donc 

je préfère les occulter.

Lister vos lecteurs/carte :

```
 

opensc-tool -l 

```

Ce qui me donne pour ma part :

```

Readers known about:

Nr.    Driver     Name

0      openct     Schlumberger E-Gate

1      openct     OpenCT reader (detached)

2      openct     OpenCT reader (detached)

3      openct     OpenCT reader (detached)

4      openct     OpenCT reader (detached)

```

	OpenSC,  comme vous  le  voyez peut  gérer  jusqu'à 5  lecteurs en  même temps.  Ça  peut être  pratique  si  vraiment 

vous  avez  un  trousseau de  clés conséquent à utiliser.

5 - Les outils PKCS:

	OpenSC  fournit des  outils  pour gérer  des  structure PKCS  (structure standard pour  le stockage de paire  de clés, 

certificats etc...)   Je passe sur pkcs11-tool, ne l'ayant  pas utilisé.  Vous avez donc  deux outils : pkcs15-init

et pkcs15-tool le premier sert à  initialiser la smartcard et le second à lister son contenu etc...

	C'est à  partir de  pkcs15-init que vous  pourrez initialiser  la carte, créer de nouveau User Pin et insérer vos 

données sensibles.

Initialisation de la carte:

```
 

pkcs15-init -ECT -r <le_numero_de_lecteur_avec_la_carte_a_initialiser>

```

	Suivez ce qui  vous est demandé c'est à dire de remplir le code SO Pin puis le SO Puk.

Création d'un nouveau User Pin:

```
 

pkcs15-init -T -P -a <auth_id> -l <label> -r <num_du_lecteur> 

```

	auth_id peut être omis, si  c'est votre premier pin par défaut l'auth_id aura  le numéro (en  héxa) 01.   

	label peut  aussi être  omis mais  préferrez en mettre un  pour que ça soit  plus clair.  

	le  numéro du lecteur peut  aussi être omis si vous avez qu'un lecteur de branché.

Insertion des données sensibles:

Il existe 2 méthodes, du moins pour la paire de clé :

- soit vous générez en  interne la paire de clé, ce qui  a l'avantage que jamais la clé privé  n'aura existée sur un  

autre support que la clé  elle-même mais il faut pour cela que votre carte le permette.  

- soit vous  utilisez un  logiciel de  génération de clé  (au format  PEM) comme OpenSSL et  vous les téléchargez dans

la carte.  Cette dernière  méthode est la plus facile si vous devez créer un certificat en plus de la paire de clé.

Auto-génération de la paire de clé:

```
 

pkcs15-init -G RSA/<longueur_clé> -a <auth_id_du_user_pin_cible> --key-usage <usage_clé> -r <num_du_lecteur> 

```

	La  longueur de la  clé peut  aller jusqu'à  2048 (en  tout cas  sur les e-gate). Ne vous  affolez pas si ça met  	

du temps à être générer :  la carte n'a pas non  plus une  super-puce. 

auth_id  doit être  celui du User  Pin dans lequel vous voulez mettre  cette paire de clés. Ce User Pin  ne doit pas déjà en posséder sinon  vous aurez une erreur.   

usage_key peut être :  sign, decrypt ou les deux (séparés par une virgule).  'sign' donne la possibilité à la paire de clé

de signer (pour créer des certificats etc...), 'decrypt' de décrypter des données.

Génération de la paire de clé avec OpenSSL:

```
 

openssl req -newkey rsa:<longueur_clé> -keyout key.pem -out cert-req.pem

```

Puis stockage :

```
 

pkcs15-init -s key.pem -a <auth_id_du_User_Pin_cible> --key-usage <usage_clé> -r <num_du_lecteur> 

```

Vous pouvez générer aussi un certificat allant avec cette paire de clé :

```
      

openssl x509 -req -signkey key.pem -in  cert-req.pem  -out  cert.pem

```

Et le stocker de cette manière :

```
 

pkcs15-init -X cert.pem -v -a <auth_id_du_Uuser_Pin_cible> -r <num_du_lecteur> 

```

	A moins que vous sachiez ce que  vous faites avec votre paire de clé qui a été créée sur le disque dur  avec OpenSSL, 

pensez à supprimer les fichier .pem après cette manip.

	Notez toutefois que si vous voullez avoir la possibilité de récupérer la clé  privée  (ce  qui  n'est  pas  recommandé)  

vous  pouvez  utiliser  l'option "--extractable" lors de la génération/insertion  de la paire de clé. Vous pouvez

aussi basculer  en mode  "unsecure" grâce à  l'option "--insecure" qui  fait que vous pouvez ne pas  utiliser de code PIN 

pour accéder à  la clé privé...à bannir donc.

Lister les infos de votre smartcard:

	Je vais pas m'étendre sur l'outil pkcs15-tool qui est simple à utiliser.

	Pour tout lister :

```
 

   pkcs15-tool --list-pins -c -C -k --list-public-keys

   
```

(J'évite de vous sortir un dump pour exemple parce que c'est assez long...)

6 - Utiliser votre smartcard:

OpenSSH:

	Ce dernier nécéssite d'être "re-emergé" afin que le USE "smartcard" soit pris en compte.

	L'interêt de la  smartcard c'est de pouvoir vous  authentifier avec sous ssh (pour  un serveur particulier).   

Tout d'abord il  faut que le  serveur vous reconnaisse:

Sur le serveur faites :

```
 

ssh-keygen -D <num_lecteur>:<id_cle> >> /etc/ssh/ssh_known_hosts 

```

	Ou bien vous générez en local le fichier de sortie (par la même commande mais avec  un fichier en local)  et vous 

inserez  le contenu de ce  fichier dans votre  compte   ssh  distant   ~/.ssh/authorized_keys  ou  bien   vous  reprenez

directement avec  la même commande  sur le serveur  mais en pointant  le fichier ~/.ssh/authorized_keys.

Préferrez la 2ème solution (enfin c'est mon avis perso)

id_cle doit être l'ID de la clé choisie pour ce travail.

Ce qui donne, sur la machine locale :

```

ssh-keygen -D <num_lecteur>:<id_cle> >> cert_ssh

```

le contenu de cert_ssh que vous copiez dans ~/.ssh/authorized_key du compte distant

ou bien si vous avez un accès physique au compte (qui devra être accéssible de manière distante ensuite):

```

ssh-keygen -D <num_lecteur>:<id_cle> >> ~/.ssh/authorized_key

```

	Ensuite pour vous connecter c'est tout simple :

```
 

ssh -I <num_lecteur> user@host 

```

	Le User Pin correspondant à cette clé va vous être demandé, donnez le et vous voilà connecté.

Se logger avec une smartcard:

	Alors ça c'est un petit tip sympa et qui, en plus de faire classe  :Cool: , est très souple.

	Pour cela il faut juste configurer PAM.

	Ouvrez le fichier /etc/pam.d/login et ajoutez cette petite ligne au début du fichier (après la ligne avec #%PAM-1.0)

```

   auth       sufficient  /lib/security/pam_opensc.so

   
```

	Grâce à cela vous aurez la possibilité de soit vous logger grâce à la smartcard sur le user donné en login soit,

	le cas échéant, de passer normalement en fournissant votre password habituel.

	(dans le cas où vous passez par la smartcard, le password à donner doit être le user PIN correspondant au 

	certificat stocké dans votre repertoire home. cf plus bas)

	Notez le "sufficient" en première ligne, il permet à l'utilisateur de se logger avce la smartcard seule, mais si 

	il ne l'a pas il passe directement à la manière habituelle : par password. Rien de vous empèche de mettre required

	mais alors dans ce cas là n'oubliez pas votre smartcard  :Wink:  et surtout n'oubliez pas de faire ce qui suit (qui est 

	obligatoire si vous voulez que votre user se logge par smartcard, que vous ayez mis "sufficient" ou "required" dans le

	fichier login de pam)

	Il faut en effet que le certificat de vérification se trouve dans votre compte user (comme pour ssh en fait). Pour cela c'est

	c'est très simple, faites :

```

   $ mkdir ~/.eid/

   $ pkcs15-tool -r <id_certificat> -o ~/.eid/authorized_certificates

   
```

	Si vous n'avez creer qu'un PIN avec clé et certificat alors l'id est, par défaut, 45.

Note: si vous voulez mettre "required" pour la smartcard dans le fichier login de pam, essayez d'abord avec "sufficient" 

	pour voir si tout fonctionne au poil. Ca serez bête de ne pas pouvoir vous logger parce que vous auriez mis un mauvais certificat 

	ou autre...

	(Dans le pire des cas un reboot sur livecd, chroot et tout le toutim vous donnera la possibilité d'éditer le fichier login 

	et de résoudre le problème. Il faut toujorus avoir un livecd gentoo sur soit.)

OpenSSL:

	Il  s'agit  de lister  les  commandes  permettant  d'intéragir avec  les smartcards au travers d'OpenSSL. 

	Lancez openssl avec la commande du  même nom, vous obtenez une invite de commande.  Chargeons le  moteur pour accéder 

à la smartcard. Il  en existe 2. Si vous n'avez jamais  qu'une seule smartcard vous pouvez vous  satisfaire du moteur "opensc"

cependant il semble être assez buggé  d'après ce que j'ai pu voir mais peut-être était-ce dû  au support de  ma smartcard 

(une  e-gate), je ne sais  pas. Utilisez plutôt le moteur "pkcs11" qui permet d'accéder au lecteur de son choix.

(Je  vous laisse la  charge de  configurer OpenSSL  dans /etc/ssl/openssl/cnf c'est assez facile. pour plus d'info -> mp)

Charger le moteur opensc:

```

OpenSSL> engine dynamic -pre SO_PATH:/usr/lib/opensc/engine_opensc.so -pre ID:opensc -pre LIST_ADD:1 -pre LOAD

(dynamic) Dynamic engine loading support

[Success]: SO_PATH:/usr/lib/opensc/engine_opensc.so

[Success]: ID:opensc

[Success]: LIST_ADD:1

[Success]: LOAD

Loaded: (opensc) opensc engine

OpenSSL> 

```

Charger le poteur pkcs11 (recommandé):

```

OpenSSL> engine dynamic -pre SO_PATH:/usr/lib/opensc/engine_pkcs11.so -pre ID:pkcs11 -pre LIST_ADD:1 -pre LOAD -pre MODULE_PATH:/usr/lib/pkcs11/opensc-pkcs11.so

(dynamic) Dynamic engine loading support

[Success]: SO_PATH:/usr/lib/opensc/engine_pkcs11.so

[Success]: ID:pkcs11

[Success]: LIST_ADD:1

[Success]: LOAD

[Success]: MODULE_PATH:/usr/lib/pkcs11/opensc-pkcs11.so

Loaded: (pkcs11) pkcs11 engine

OpenSSL> 

```

Voici une liste non-exhaustive de commandes possibles:

(Ces commandes fonctionnent aussi avec le moteur 'opensc')

Générer une requete de certificats:

```

OpenSSL> req -engine pkcs11 -new -key slot_<num_lecteur>-id_<id_clé>  -keyform engine -out cert.req -text

```

Générer un certificats auto-signe ("self-signed" quoi):

```

OpenSSL> x509 -req -engine pkcs11 -in cert.req -signkey slot_<num_lecteur>-id_<id_clé>  -out cert.pem -keyform engine -text

```

Vérifier une requete de certificat au travers de la carte:

```

OpenSSL> req -in cert.req -verify -engine pkcs11 -key slot_<num_lecteur>-id_<id_clé> -keyform engine -text 

```

	On peut bien  evidemment faire pas mal de  chose mais cela nécéssiterait un howto OpenSSL complet sur ce sujet.

Firefox:

	Alors là pas plus simple: le support de smartcard est natif du coup la manip est vraiment simplifiée.

	Allez dans "Edition"->"Préférences"

	Choisissez la zone "Avancé"

	Dans cette zone, descendez jusqu'à tomber sur la partie "Certificats"

	Cliquez sur le bouton "Gérer les périphériques de sécurité"

	Une boîte de dialoque s'ouvre et cliquez alors sur "Charger"

	Comme nom du module mettez "Opensc" (par exemple mais vous en faites ce que vous voulez)

	puis comme nom de fichier du module mettez le chemin suivant : "/usr/lib/pkcs11/opensc-pkcs11.so"

	Faites "ok" et voilà vous allez voir apparaître vos lecteurs avec les clés et les données s'il y en a.

	(note : le code pin vous sera demandé au cas où vous devez accéder à des données protégées)

	Ceci est utilisable sur le protocole https par exemple où le certificats n'est pas diffusé. Imaginez que vous 

	ayez un accès en https sur un site et que c'est à vous de fournir le bon certificat: la smartcard est un support 

	tout trouvé.

Thunderbird:

	La manip est exactement la même que pour firefox.

	Refaites donc la même chose vu au dessus.

OpenVPN:

	A priori OpenVPN supporte l'accès aux smartcard. Je n'ai pas encore pu testé mais ça va venir.

	TODO

7 - Liens:

Le projet OpenSC : http://opensc.org/   (projet qui comprend opensc et openct)

Le projet M.U.S.C.L.E : http://www.linuxnet.com/

Pour plus d'infos vous pouvez me contacter par mp où bien poser les questions sur ce topic.

Toutes réflexions constructives sur ce howto sont les bienvenues!

(correction de l'orthographe, précision sur certains points, ou même refonte de certaines choses etc...)

----------

## boozo

'alute

merci pour l'effort de vulgarisation  :Cool: 

personnellement je viens de découvrir les smartcards avec ton howto et celà m'a l'air vachement professionnel ton truc  :Wink:  j'avais déjà essayé un truc similaire avec pam_usb (attends que je retrouve les liens...) qui marchait pas mal toutefois de mémoire c'était bien plus simple a mettre en oeuvre alors je me doute qu'il y a une différence entre les deux techniques (autres que les supports) mais je ne suis pas capable d'en apprécier les nuances alors si tu un moment pour m'expliquer un peu des subtilités/avantages de cette stratégie de crytpo... merci pour tes lumières  :Smile: 

[Edit] à y'est j'ai retrouvé c'est celà et j'avais un autre lien aussi

----------

## l.slysz

le probleme avec le systeme usb, vient du fait que les clé sont lisibles sur la clé usb, donc n'importe qui qui te vole ta clé usb peut les utiliser  :Confused: 

----------

## boozo

haaa effectivement je n'avais pas bien lu  :Wink: 

mille excuses ! J'suis vraiment nul en plus c'est dit clairement pourtant...  :Embarassed: 

 *Quote:*   

>  La principale raison de ces cartes est que la clé privée
> 
> (donc la clé la plus sensible!) peut être stockée sans pour autant pouvoir être lue. C'est à dire qu'une fois
> 
> la clé privée installée (générée ou copiée puis supprimée) personne n'est en mesure de la récupérer.
> ...

 

[Edit] Put*** ! Et dire que c'est sur cette belle chouille que je change de rang...  :Mr. Green: 

----------

## kwenspc

oui voilà c'est en effet LE principal avantage de ces clés.

ça ne coûte pas trés cher. un clé e-gate (un mini lecteur usb donc) et 5 cartes sims ça vaut dans les 35 dollars par là.

ah oui parce que chose bizarre : c'est pas facile du tout d'en trouver en France alros que la technologie est europpéenne (voir Française!).

du coup faut les acheter sur des sites d'outre-atlantique...

en tout cas cette technologie a le vent en poupe dans les grosse boites. ça ne résout pas le problème de la "perte de mot de passe" par l'employé (oui faut tout de même qu'il connaisse son code pin) mais ça met un verrou de plus (sans la clé, même si on a le code pin on peut rien faire).

(pour les e-gate voilà où en acheter : http://www.market.axalto.com/)

----------

## expl0rer

 *Quote:*   

> ça ne coûte pas trés cher. un clé e-gate (un mini lecteur usb donc) et 5 cartes sims ça vaut dans les 35 dollars par là.

 

Euh comment dire, je crois que tu t'es un peu gourré dans les prix, c'est pas bien de prendre le matos du boulot  :Wink: 

le lecteur fait environ 10$ et les cartes sont entre 21 et 23$ l'unité, mais par lot de 5 ce qui fait 105$, ca fait plus du  tout la meme chose.

Mais tu as ce site en Suisse qui est moins cher pour les lecteurs et ou tu peux commander les cartes à l'unité : https://it-secure.dynalias.com/

mais sinon le howto est excellent j'en cherchais un justement, merci  :Wink: 

----------

## kwenspc

sur http://www.market.axalto.com/

cherches "Cryptoflex e-gate 32k with plug"

c'est 23,10 dollars 

t'as 1 (et non 5 dslé *) carte sim et le petit lecteurs avec.

* ah merde mal lu   :Sad:   bon en principe y a moyen d'avoir 1 pack. mais c'est vrai que celle que j'utilise c'est pas moi qui l'ait acheté.

----------

## expl0rer

Non, le "With plug" veut juste dire qu'il integre l'interface de communication dans la puce de la carte et qu'il te faut de tout facon le reader (il fait juste la connection usb carte sim, avec un composant de protection de surtension)

 *Quote:*   

> Cyberflex e-gate 32k with plug - Out of stock. Please check back within the next 2-3 weeks.
> 
> Incorporates the USB interface electronics normally found in a smart card reader on the card itself. (available in packs of 5)
> 
> Price: 	$   23.10 USD
> ...

 

Ca fait cher quand meme si tu peux pas recupéré les cartes quelques part.

edit : et si t'en commande qu'une, il te dit qu'il faut minimum

----------

## kwenspc

me --> doit réapprendre le rosbeef   :Embarassed: 

faudrait que je demande où il les a eu celui qui me les as filé.

----------

## expl0rer

Si t'as la réponse je suis intéréssé aussi  :Wink: 

----------

