Intégration des smartcards (PC/SC, CCID, OpenSC) dans IPFire

Important : gardez les chemins d’installation et les règles udev sous contrôle et testez les lecteurs smartcard sur une machine de développement avant tout déploiement en production.

Objectif principal

Ce guide détaille l’intégration de tokens matériels (smartcards) et de leurs lecteurs compatibles CCID dans l’environnement IPFire. Les composants compilés et empaquetés sont :

• pcsc-lite (daemon PC/SC)
• CCID (pilotes libres pour lecteurs de cartes)
• OpenSC (outils et bibliothèques open source pour smartcards)

Variantes d’intention liées : installation smartcard IPFire, compilation pcsc-lite, empaquetage pakfire, pilotes CCID Linux, configuration OpenSC.

TL;DR technique rapide

• Compiler pcsc-lite, CCID et OpenSC dans le shell LFS d’IPFire.
• Résoudre les erreurs de configure en exportant PKG_CONFIG_PATH et en passant PCSC_CFLAGS.
• Copier et nettoyer les rootfiles pour la construction des paquets.
• Créer les répertoires src/paks/* et y ajouter install.sh/uninstall.sh/update.sh.
• Construire les paquets ipfire et les déployer sous /opt/pakfire/tmp sur la machine cible.

Contexte et cas d’usage

Les smartcards et autres tokens matériels servent à :

• authentification web sécurisée,
• authentification sur poste de travail (login local),
• chiffrement de fichiers,
• tunnels VPN (OpenVPN, L2TP),
• chiffrement et signature d’e‑mails.

OpenSC fournit l’accès PKCS#11 (API) et la structure de gestion PKCS#15. PC/SC (pcsc-lite) est le démon d’accès aux cartes sur Linux, et CCID contient les pilotes pour de nombreux lecteurs USB.

Quelques fabricants pris en charge par OpenSC : ASEPCOS, FTCOSPK01C, OpenPGP Card, Cyberflex, CardOs, STARCOS.

Prérequis

• Environnement de build IPFire (voir article précédent pour la mise en place du LFS/IPFire build environment).
• Accès root sur l’environnement de build.
• Paquets sources placés dans /usr/src/cache (pcsc-lite, ccid, opensc).
• Outils de base : make, gcc, autotools, pkg-config.

Préparer le shell de test d’IPFire

Lancer le shell de développement LFS d’IPFire depuis la racine du dépôt :

./make shell

Les sources se situent dans /usr/src/cache sur l’environnement de build ; placez-y les archives nécessaires.

Compiler pcsc-lite

1. Vérifiez que le paquet source pcsc-lite est présent :

2. Installer la dépendance de développement udev :

apt-get install libudev-dev

3. Extraire et lancer ./configure :

tar -xf pcsc-lite-1.8.18.tar.bz2
./configure

4. Vérifier qu’aucune erreur n’apparaît au configure :

5. Compiler et installer :

./make
./make install

6. Notez les chemins d’installation affichés par l’install pour les inclure plus tard :

7. Vérifier que pcscd tourne :

Compiler CCID (pilotes)

1. Placer l’archive ccid dans le cache.

2. Lancer ./configure ; si configure ne trouve pas pcsc-lite, vous verrez une erreur :

3. Relancer configure en précisant PCSC_CFLAGS :

./configure PCSC_CFLAGS=-I/usr/local/include/PCSC

4. Si pkg-config ne trouve pas libpcsclite.pc (cas fréquent en LFS IPFire), exportez PKG_CONFIG_PATH :

export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig/

5. Relancer configure :

./configure PCSC_CFLAGS=-I/usr/local/include/PCSC

6. Si configure détecte correctement les fichiers PCSC, il affichera les vérifications réussies :

7. Compiler et installer :

./make
./make install

8. Copier les règles udev pour les lecteurs smartcard vers /etc/udev/rules :

Copier le fichier 92_pcscd_ccid.rules dans /etc/udev/rules pour que les lecteurs USB soient détectés correctement.

Compiler OpenSC

1. Placer l’archive OpenSC dans /usr/src/cache et lancer ./configure pour vérifier les dépendances :

2. La sortie du configure peut être longue ; assurez-vous que les dépendances (libusb, pkcs11-helper, libpcsclite, etc.) sont présentes :

3. Compiler et installer :

./make
./make install

4. Vérifier l’installation d’OpenSC dans le shell :

Construire les addons IPFire (pakfire)

Après installation réussie dans le shell LFS, l’étape suivante est la transformation en paquets IPFire (.ipfire) via les scripts LFS et make.sh.

Pré-requis : lire la section “Building PSAD addon” de l’article précédent pour la méthodologie complète.

Points clés :

• Placer un script LFS (lfs script) pour chaque package dans le répertoire lfs/.
• Mettre à jour make.sh pour inclure les nouveaux paquets.

Les lfs scripts ont été créés pour : pcsc-lite-1.8.18, ccid-1.4.24 et opensc-0.16.0.

Exemples visuels des scripts LFS :

Mettre à jour make.sh pour gérer les nouveaux paquets (ajouts visibles dans le script) :

Construire les paquets avec ipfiremake :

ipfiremake pcsc-lite
ipfiremake ccid
ipfiremake opensc

Puis lancer le build global (parfois nécessaire deux fois) :

./make.sh build

Si vous voyez un message indiquant que les rootfiles ne sont pas trouvés, générez les logs ; trois rootfiles seront présents dans log/.

Copiez-les vers config/rootfiles/packages et renommez-les pour correspondre au nom LFS du paquet :

cp log/pcsc-lite-1.8.18 config/rootfiles/packages/pcsc-lite
cp log/ccid-1.4.24 config/rootfiles/packages/ccid
cp log/opensc-0.16.0 config/rootfiles/packages/opensc

Remarque : les rootfiles peuvent contenir un signe “+” en tête ; il faut le retirer :

sed -i 's/+//g' config/rootfiles/packages/pcsc-lite
sed -i 's/+//g' config/rootfiles/packages/ccid
sed -i 's/+//g' config/rootfiles/packages/opensc

Vérifiez que les “+” ont bien été retirés :

Préparer les scripts pakfire

Créer les répertoires src/paks/pcsc-lite, src/paks/ccid, src/paks/opensc et copier les scripts par défaut (install.sh, uninstall.sh, update.sh) depuis src/paks/default/ :

Relancer la construction :

./make.sh build

Ignorez les messages de rootfiles manquants si vous les avez déjà ajoutés dans config/.

À la fin, les paquets .ipfire doivent apparaître dans le répertoire packages :

Installer les paquets sur une machine IPFire en production

1. Copier les paquets compilés sur la machine IPFire cible dans /opt/pakfire/tmp :

2. Vérifier la présence des fichiers :

3. Déballer chaque paquet :

 tar -xvf pcsc-lite-1.8.18-2.ipfire
 tar -xvf ccid-1.4.24-2.ipfire
 tar -xvf opensc-0.16.0-2.ipfire

4. Lancer l’installation via les scripts fournis :

./install.sh

5. Vérifier l’installation : pcsc-lite, CCID et OpenSC doivent être installés et leurs binaires accessibles.

Vérifications post‑installation

• Vérifier que le démon pcscd tourne : ps aux | grep pcscd ou systemctl status pcscd si présent.
• Lister les lecteurs détectés :

pcsc_scan

• Tester l’accès à la carte via OpenSC :

opensc-tool -l
pkcs11-tool --list-slots

• Vérifier les règles udev et les permissions du device (/dev/bus/usb/…, /dev/pcsc/* selon configuration).

Dépannage courant

• Erreur configure CCID “pcsc-lite not found” : exporter PKG_CONFIG_PATH et fournir PCSC_CFLAGS vers /usr/local/include/PCSC.
• Erreur liée à des fichiers .pc manquants : vérifiez l’installation de pkg-config et les chemins /usr/local/lib/pkgconfig.
• Lecteur non détecté : vérifier règles udev, redémarrer udev, brancher le lecteur sur un autre port USB et relancer pcscd.
• Permissions : s’assurer que l’utilisateur qui exécute pcscd a accès aux devices USB.

Mini‑méthodologie de projet (étapes rapides)

1. Préparer l’environnement LFS et placer les sources dans /usr/src/cache.
2. Compiler et tester localement pcsc-lite, CCID, OpenSC dans le shell LFS.
3. Créer lfs scripts et modifier make.sh pour inclure les paquets.
4. Construire les paquets .ipfire, copier les rootfiles, nettoyer les caractères indésirables.
5. Préparer les scripts pakfire (install/uninstall/update).
6. Construire à nouveau, récupérer les paquets, les copier sur IPFire cible et installer.
7. Valider avec pcsc_scan et pkcs11-tool.

Checklist par rôle

Administrateur système :

• Vérifier compatibilité matérielle des lecteurs CCID.
• Installer libudev-dev et dépendances avant compilation.
• Exporter PKG_CONFIG_PATH si nécessaire.
• Redémarrer udev si les règles sont modifiées.

Développeur de paquets / intégrateur :

• Placer les lfs scripts dans lfs/.
• [ ] Mettre à jour make.sh et tester ./make.sh build deux fois.
• Copier et nettoyer les rootfiles.
• Préparer puis tester install.sh/uninstall.sh/update.sh.

Responsable sécurité / compliance :

• Évaluer l’usage des tokens pour les flux sensibles (VPN, e-mail).
• Documenter politiques d’émission des cartes et cycle de vie.
• Tester procédures de révocation et rotation des certificats.

Arbre de décision (choisir l’approche d’intégration)

flowchart TD
  A[Besoin d'authentification matérielle?] -->|Non| B[Ne pas intégrer smartcards]
  A -->|Oui| C[Serveur IPFire déjà en place?]
  C -->|Non| D[Préparer environnement LFS / build]
  C -->|Oui| E[Avez-vous accès au build system?]
  E -->|Oui| F[Compiler pcsc-lite/CCID/OpenSC et créer paquets]
  E -->|Non| G[Utiliser hardware token compatible sans compilation 'ex: PKCS#11 via agent externe']
  F --> H[Déployer paquets sur IPFire et tester]
  H --> I[Production : déployer, monitorer, policy]
  G --> I
  D --> F

Quand cette approche peut échouer (contre‑exemples)

• Environnements où l’installation de paquets personnalisés est interdite (politiques strictes).
• Lecteurs propriétaires sans pilote CCID disponible et sans documentation pour développer un pilote.
• Cas où l’interface USB est bloquée ou isolée par des règles matérielles/BIOS.

Alternatives

• Utiliser un service d’authentification central (RADIUS/AD) avec EAP-TLS et un middleware de tokens plutôt que d’installer OpenSC sur le firewall.
• Externaliser la gestion PKCS#11 à une appliance ou à un HSM si vous avez besoin d’une sécurité physique renforcée.

Sécurité et confidentialité

• Limitez l’accès aux périphériques USB et aux sockets PC/SC via des règles udev et des ACL sur les binaires.
• Sur IPFire, isoler le démon pcscd et limiter ses privilèges au minimum nécessaire.
• Documenter le cycle de vie des cartes (émission, suspension, révocation) et chiffrer les sauvegardes de profil PKCS#15 si stockées.
• GDPR : si des données personnelles transitent via les certificats, veillez aux règles de conservation et à la minimisation des données.

Critères d’acceptation / Test cases

• pcscd démarre automatiquement et reste en état “running” après reboot.
• Un lecteur CCID branché est détecté par pcsc_scan.
• opensc-tool liste la carte et pkcs11-tool affiche au moins un slot.
• Les paquets .ipfire installés sont réversibles via uninstall.sh sans laisser de fichiers temporaires.

Glossaire (1 ligne chacun)

• PC/SC : API et modèle client/serveur pour accéder aux smartcards.
• CCID : Spécification et pilotes pour lecteurs de cartes à puce USB.
• OpenSC : Ensemble d’outils et bibliothèques open source pour smartcards et PKCS#11.
• pkcs11-tool : Outil pour interagir avec les modules PKCS#11.
• pcscd : Démon qui gère l’accès aux lecteurs et cartes via PC/SC.

Points d’attention locaux et migration

• Conserver la compatibilité avec la version IPFire ciblée (ici 2.19) — vérifier les chemins et les versions des bibliothèques avant de migrer.
• Si vous migrez vers une version d’IPFire plus récente, répétez la compilation dans le nouvel environnement LFS pour éviter des incompatibilités binaires.

Résumé final

Ce guide a présenté l’intégration complète des composants smartcard (pcsc-lite, CCID, OpenSC) dans IPFire, depuis la compilation dans le shell LFS jusqu’à la création des paquets pakfire et leur installation sur un système IPFire. Les étapes critiques incluent la gestion du PKG_CONFIG_PATH, la copie et le nettoyage des rootfiles, et la préparation des scripts pakfire. Testez systématiquement avec pcsc_scan et pkcs11-tool avant tout déploiement en production.

Notes

• Conservez toujours une machine de test isolée pour valider les drivers et les règles udev avant tout changement sur des firewalls en production.
• Documentez toutes les modifications (scripts make.sh, rootfiles modifiés, règles udev ajoutées) pour faciliter les audits et le support.