Smartcards mit IPFire integrieren: PC/SC, CCID und OpenSC

Kurzfassung: Diese Anleitung beschreibt, wie PC/SC (pcsc-lite), CCID-Treiber und OpenSC in der IPFire-Entwicklungsumgebung kompiliert, als Pakete gebaut und auf ein laufendes IPFire-System installiert werden. Sie enthält Schritte zur Vorbereitung der Umgebung, zur Fehlerbehebung bei typischen Konfigurationsproblemen und Checklisten für Administratoren und Entwickler.

Wichtig: Diese Anleitung baut auf einem vorherigen Artikel zur IPFire-Entwicklung auf — dort sind Basis-Schritte zur Entwicklungsumgebung und zum Erstellen von LFS-Addons beschrieben.

Einleitung

Ziel dieses Artikels ist es, Hardware-Tokens wie Smartcards und CCID-kompatible Leser in IPFire zu integrieren. Die hier verwendeten Komponenten sind freie Software und wurden erfolgreich in IPFire 2.19 kompiliert und als Pakete (ipfire-addons) gebaut:

• pcsc-lite (PC/SC Smart Card Daemon)
• CCID (Treiber für Chip-/Smartcard-Reader)
• OpenSC (Tools und Bibliotheken für Smartcards, PKCS#11- und PKCS#15-Unterstützung)

Kurz erklärt:

• PC/SC: Schnittstelle für Smartcard-Zugriff auf Unix/Linux.
• CCID: Treiber-Implementierung für viele USB-Smartcard-Reader.
• OpenSC: Verwaltung von Smartcards, PKCS#11-Provider und Kommandozeilen-Tools.

Einsatzszenarien für Smartcards auf IPFire:

• Sicheres Web-Login
• Workstation-Login
• Datei- und Datenträgerverschlüsselung
• VPN-Authentifizierung (z. B. OpenVPN, L2TP)
• E-Mail-Verschlüsselung und Signatur

Hersteller, die häufig von OpenSC unterstützt werden, beinhalten ASEPCOS, FTCOSPK01C, OpenPGP Card, Cyberflex, CardOS und STARCOS.

Voraussetzungen

Vor Beginn sollten Sie folgendes sicherstellen:

• Zugriff auf das IPFire-Quell-Repository und eine funktionierende Entwicklungsumgebung wie in der vorherigen Anleitung beschrieben.
• Beherrschung grundlegender Linux-Kommandos und root-Zugriff im IPFire-Entwicklungs-LFS-Shell.
• Die Quellpakete für pcsc-lite, ccid und opensc müssen im Ordner /usr/src/cache liegen.

Hinweis: Pfade und Dateinamen in dieser Anleitung entsprechen dem IPFire-Build-Layout der Version 2.x.

Umgebung einrichten

Starten Sie die LFS-Testumgebung über die IPFire-Buildumgebung mit:

./make shell

Die Quellpakete werden in /usr/src/cache abgelegt. Überprüfen Sie, ob pcsc-lite, ccid und opensc dort vorhanden sind.

Beispiel: Das pcsc-lite-Archiv im Cache

pcsc-lite kompilieren und installieren

1. Installieren Sie erforderliche Entwicklungsabhängigkeiten in der LFS-Shell. Mindestens libudev-Entwicklungspakete werden benötigt:

apt-get install libudev-dev

2. Entpacken und konfigurieren:

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

Bei erfolgreichem configure sehen Sie keine Fehler.

3. Kompilieren und installieren:

make
make install

Nach der Installation werden wichtige Installationspfade angezeigt, die wir später für CCID benötigen.

4. Prüfen, ob der Daemon läuft:

Wenn pcscd läuft, ist die Basis für Smartcard-Zugriffe vorhanden.

CCID-Treiber kompilieren und installieren

1. Wechseln Sie ins Cache-Verzeichnis und entpacken Sie das CCID-Archiv.

2. Häufig entsteht beim ./configure ein Fehler, weil pcsc-lite-Header oder pkg-config-Dateien nicht gefunden werden. Beispiel: “pcsc-lite not found”.

3. Lösen Sie diesen Fehler, indem Sie PCSC_CFLAGS setzen und sicherstellen, dass pkg-config den richtigen Pfad verwendet:

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

Sollte pkg-config libpcsclite.pc nicht finden, exportieren Sie PKG_CONFIG_PATH:

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

Und starten Sie configure erneut:

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

Bei erfolgreicher Erkennung werden die PCSC-Header und Bibliotheken gelistet.

4. Kompilieren und installieren:

make
make install

5. Kopieren Sie udev-Regeln für Smartcard-Reader nach /etc/udev/rules, damit Geräte korrekt erkannt und Berechtigungen gesetzt werden:

cp drivers/92_pcscd_ccid.rules /etc/udev/rules/

Achten Sie darauf, die Regeldatei 92_pcscd_ccid.rules im Zielordner zu sehen.

OpenSC kompilieren und installieren

1. Wechseln Sie ins Cache-Verzeichnis und entpacken Sie opensc. Prüfen Sie mit ./configure die Abhängigkeiten:

Die configure-Ausgabe informiert über erkannte Bibliotheken und deaktivierte Features:

2. Kompilieren und installieren:

make
make install

3. Verifizieren Sie die Installation:

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

Wenn OpenSC korrekt installiert ist, können Sie Smartcard-Informationen abfragen und PKCS#11-Module nutzen.

Addon-Build für IPFire erstellen

Nachdem die Tools im LFS-Testshell installiert sind, erstellen wir IPFire-Addons im Pakfire-Format.

Wichtig: Die grundlegende Methode zum Erstellen eines Addons (LFS-Skript, Anpassungen an make.sh und Konfiguration) wurde im vorherigen Artikel beschrieben. Kurz zusammengefasst:

• Für jedes Paket wird ein LFS-Skript in das Verzeichnis lfs/ gelegt.
• Makefile-Änderungen und Paket-Metadaten werden in make.sh und config/ vorgenommen.

Kopieren Sie die LFS-Skripte für die drei Pakete in das lfs-Verzeichnis:

Beispiele der LFS-Skripte in der Ansicht:

Änderungen an make.sh sorgen dafür, dass die neuen Pakete im Build berücksichtigt werden.

Build-Prozess ausführen

Führen Sie folgende Befehle aus, um die Pakete zu erzeugen:

ipfiremake pcsc-lite
ipfiremake ccid
ipfiremake opensc

Alternativ oder zusätzlich innerhalb des Build-Systems:

./make.sh build

Hinweis: Bei komplexen Addons ist es oft notwendig, ./make.sh build zweimal zu starten, damit Abhängigkeiten vollständig aufgelöst werden.

Wenn beim ersten Durchlauf Rootfiles fehlen, werden diese in /log erzeugt. Kopieren Sie die Rootfiles nach config/rootfiles/packages und passen Sie deren Namen an das LFS-Paket an:

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

Gelegentlich enthalten diese Rootfiles ein führendes “+”-Zeichen, das entfernt werden muss:

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

Vergewissern Sie sich, dass die Pluszeichen entfernt wurden:

Pakfire-Pakete vorbereiten

Pakfire ist das Paketverwaltungstool von IPFire. Für jedes Paket muss ein Verzeichnis unter src/paks/ mit install.sh, uninstall.sh und update.sh existieren. Kopieren Sie die Standardskripte in die jeweiligen Verzeichnisse:

mkdir -p src/paks/pcsc-lite src/paks/ccid src/paks/opensc
cp src/paks/default/install.sh src/paks/pcsc-lite/
cp src/paks/default/uninstall.sh src/paks/pcsc-lite/
cp src/paks/default/update.sh src/paks/pcsc-lite/
# und entsprechend für ccid und opensc

Starten Sie den Build erneut:

./make.sh build

Nach Abschluss finden Sie die generierten IPFire-Pakete in packages/:

Beispiele: pcsc-lite-1.8.18-2.ipfire, ccid-1.4.24-2.ipfire, opensc-0.16.0-2.ipfire.

Pakete auf ein laufendes IPFire kopieren und installieren

Kopieren Sie die erzeugten Pakete auf das Zielsystem, z. B. nach /opt/pakfire/tmp/:

Prüfen Sie auf dem Live-System das Verzeichnis:

Entpacken Sie die Pakete vor der Installation:

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

Führen Sie das install.sh-Skript in jedem Paketverzeichnis aus:

./install.sh

Bestätigungen der Installation:

Tests und Verifikation

Nach Installation prüfen Sie:

• Läuft pcscd auf dem System? (ps/ systemctl oder prozessliste im Testshell)
• Werden USB-Reader vom Kernel erkannt? (dmesg, lsusb)
• Zeigen pkcs11-tool und opensc-tool die erwarteten Slots und Karten an?

Beispiele:

pcscd -f  # im Foreground zur Debug-Ausgabe
pcsc_scan
pkcs11-tool --module /usr/local/lib/opensc-pkcs11.so --list-slots
opensc-tool -l

Wenn ein Reader angeschlossen ist, sollte pcsc_scan ihn erkennen und Kartenoperationen Optionen anzeigen.

Fehlerbehebung und häufige Probleme

Fehler: configure findet pcsc-lite nicht

Lösung: PCSC_CFLAGS setzen und PKG_CONFIG_PATH exportieren, sodass libpcsclite.pc gefunden wird. Beispiel:

export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig/
./configure PCSC_CFLAGS=-I/usr/local/include/PCSC

Fehler: Reader wird nicht erkannt

• Prüfen Sie, ob der Kernel das Gerät erkennt: dmesg | tail
• Prüfen Sie udev-Regeln und Berechtigungen: ls -l /dev/bus/usb/… bzw. /dev/ifd oder /dev/ttyUSB
• Starten Sie pcscd im Vordergrund, um Debug-Informationen zu sehen: pcscd -f

Fehler: OpenSC findet keine Karten

• Prüfen Sie die CT-Kartenunterstützung und ob das richtige PKCS#11-Modul geladen ist.
• Testen Sie mit opensc-tool -l und pkcs11-tool.

Wichtig: Log-Dateien der daemons und systemd-journals sind die wichtigsten Hinweise bei Laufzeitfehlern.

Best Practices und Sicherheitshinweise

• Testen Sie alle Änderungen in einer isolierten Entwicklungsumgebung, nie zuerst in einer produktiven Firewall.
• Entfernen Sie Debug- und Entwicklungs-Flags vor dem Erstellen von Produktionspaketen.
• Beschränken Sie Zugriff auf Smartcard-Geräte durch Gruppen und udev-Regeln.
• Dokumentieren Sie installierte Versionen von pcsc-lite, ccid und opensc in Ihrer Systemdokumentation.

Rollenbasierte Checklisten

Administrator (Installation und Betrieb):

• Pakete in /opt/pakfire/tmp bereitstellen
• install.sh ausführen und Erfolg prüfen
• pcscd-Dienststatus prüfen
• udev-Regeln prüfen und neu laden: udevadm control –reload
• Backup der Konfigurationsdateien erstellen

Entwickler (Build und Paketierung):

• LFS-Skripte in lfs/ bereitstellen
• make.sh anpassen und testen
• Rootfiles prüfen und + entfernen
• Pakete in packages/ erzeugen
• install/uninstall/update Skripte testen

Security Officer (Freigabe und Audit):

• Prüfen, welche PKCS#11-Module geladen werden
• Zugriffsrechte auf Geräte prüfen
• Policies für Smartcard-Nutzung dokumentieren

Mini-Methodologie für Integration in 6 Schritten

1. Testumgebung vorbereiten und Quellpakete in /usr/src/cache ablegen.
2. pcsc-lite im LFS Shell kompilieren und installieren.
3. CCID konfigurieren, Probleme mit PKG_CONFIG_PATH beheben und installieren.
4. OpenSC bauen, testen und PKCS#11-Module verifizieren.
5. LFS-Skripte erstellen, Rootfiles bereinigen und Pakete bauen.
6. Pakete auf Produktionssystem kopieren und mit install.sh installieren. Funktionstest durchführen.

Kriterien für Annahme

• pcscd läuft stabil nach Reboot.
• Ein angeschlossener CCID-Reader wird erkannt und listet Karten mit pcsc_scan.
• OpenSC/pkcs11-tool zeigt Slots und Karten an.
• Pakete wurden ohne Fehler erzeugt und lassen sich installieren/entfernen.

FAQ

Was mache ich, wenn libudev-dev nicht verfügbar ist?

• Prüfen Sie alternative Paketquellen oder kompilieren Sie libudev aus den Distribution-Quellen. Ohne libudev können gewisse Hotplug-Funktionen nicht gebaut werden.

Kann ich Smartcards für VPN-Authentifizierung verwenden?

• Ja. OpenSC stellt PKCS#11-Module bereit, die von Clients/Daemons zur Authentifizierung verwendet werden können. Die VPN-Software muss PKCS#11 unterstützen oder Sie nutzen eine Client-Bridge.

Muss ich udev-Regeln manuell anpassen?

• In vielen Fällen sind die mitgelieferten Regeln ausreichend. Bei speziellen Lesermodellen oder abweichenden Vendor/Product-IDs sind Anpassungen nötig.

Zusammenfassung

Diese Anleitung zeigt, wie man pcsc-lite, CCID und OpenSC in der IPFire-Entwicklungsumgebung kompiliert, als Pakete baut und auf ein laufendes IPFire-System installiert. Wichtige Punkte sind das Setzen von PKG_CONFIG_PATH, das Korrigieren von Rootfiles für das Pakfire-Build und das Testen von Dienst- und Geräteerkennung nach der Installation.

Wichtig: Testen Sie Änderungen immer in kontrollierten Umgebungen und dokumentieren Sie Versionen und Konfigurationen für spätere Audits.

Wertvolle Kontrollfragen am Ende:

• Läuft pcscd bei Systemstart?
• Werden die Reader korrekt von udev behandelt?
• Werden Karten durch OpenSC und pkcs11-tool erkannt?

Weiterführende Schritte: Integration von Smartcard-basierten Logins oder VPN-Authentifizierung erfordert Konfiguration auf Client-Seite und eventuell zusätzliche Middleware (z. B. NSS oder OpenVPN mit PKCS#11-Unterstützung).