Raspberry Pi: Come installare il miniLector CIE su Ubuntu Server 20.04 LTS
Tags: blog, raspberrypi, linux, smartcard
Published: 2020-11-04 21:29:48

---
title: Raspberry Pi: Come installare il miniLector CIE su Ubuntu Server 20.04 LTS
published: true
date: 2020-11-04 12:56:56 UTC
tags: Blog,RaspberryPi,Linux,SmartCard
canonical_url: https://www.dontesta.it/2020/11/04/raspberry-pi-come-installare-minilector-cie-ubuntu-server-20-04-lts/
---

[![Bit4id miniLector AIR NFC v3](https://www.dontesta.it/wp-content/uploads/2020/11/IMG_1728-300x154.jpg "Bit4id miniLector CIE")](https://www.dontesta.it/wp-content/uploads/2020/11/IMG_1728-scaled.jpg)

Bit4id miniLector CIE

Qualche tempo addietro ho ricevuto il [**miniLector CIE**](https://shop.bit4id.com/prodotto/minilector-cie/?utm_source=ref_blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1) di [Bit4id](https://www.bit4id.com/it/). Si tratta di un lettore di [Smart Card](https://en.wikipedia.org/wiki/Smart_card) contact less con interfaccia [**NFC (Near-Field-Communication)**](https://en.wikipedia.org/wiki/Near-field_communication), progettato per utilizzare sia le [Carte d’Identità Elettroniche (CIE)](https://www.cartaidentita.interno.gov.it/) sia le tradizionali carte contactless, comprese le tessere [CNS (Carta Nazionale dei Servizi)](https://www.youtube.com/watch?v=TcAzn1POhsM) con interfaccia duale. Nel corso di questo articolo cercherò di guidarvi con mano nel processo d’installazione di questo lettore sul sistema operativo [**Ubuntu Server 20.04 LTS (Focal Fossa)**](https://ubuntu.com/download/server/arm), quest’ultimo installato su [Raspberry Pi 4](https://www.raspberrypi.org/products/raspberry-pi-4-model-b/?resellerType=home).

**Perchè mai installare un lettore di Smart Card sul Raspberry Pi?** Questo è il primo passo necessario alla realizzazione di un sistema di accesso basato sull’uso di Smart Card con interfaccia NFC. Lo scenario finale a cui desidero arrivare è simile a quello che ho raccontato recentemente sull’articolo [Raspberry Pi – Un esempio di applicazione della TS-CNS](https://www.dontesta.it/2020/07/17/raspberry-pi-esempio-applicazione-ts-cns-smartcard/) e reso sicuramente più chiaro dal diagramma di Figura 1.

Nel possibile scenario di Figura 1, abbiamo, il lettore di Smart Card connesso via USB al Raspberry Pi (in questo caso la versione quattro); a quest’ultimo è connesso via **GPIO** (General Purpose Input/Output) un modulo composto da quattro relè. Sul Raspberry Pi, il software installato gestisce in sicurezza l’accesso al modulo relè per le azioni di attivazione e disattivazione.

Il componente  **Access Manager** gestisce l’accesso alle informazioni di sicurezza che provengono dai dati estratti dalla Smart Card attraverso il lettore (componente **Smart Card Manager** ), questi dati sono poi utilizzati per validare l’accesso tramite il servizio **LDAP** (Lightweight Directory Access Protocol), da quest’ultimo sono anche estratte le informazioni circa le azioni che l’individuo appena identificato può compiere sui quattro relè, azioni gestiste dal componente **Relay Module Manager**.

Il componente **UI** (User Interface), che può essere di tipo testuale (vedi progetto [raspberry-pi-access-via-ts-cns](https://github.com/amusarra/raspberry-pi-access-via-ts-cns))  o grafico, rappresenta il punto d’interazione con l’utente finale, ovvero, la persona che opportunamente autorizzata, può compiere azioni sui relè connessi al Raspberry Pi.

 

[![Figura 1 - Possibile scenario d'integrazione Smart Card e Raspberry Pi](https://www.dontesta.it/wp-content/uploads/2020/11/possibile-scenario-integrazione-smartcard-raspberry-pi-1024x541.png "Figura 1 - Possibile scenario d'integrazione Smart Card e Raspberry Pi")](https://www.dontesta.it/wp-content/uploads/2020/11/possibile-scenario-integrazione-smartcard-raspberry-pi.png)

Figura 1 – Possibile scenario d’integrazione Smart Card e Raspberry Pi

 

Cosa ne pensate di questo scenario d’integrazione? Per poter realizzare quanto mostrato dal digramma di Figura 1 (la cui realizzazione non è oggetto di quest’articolo), dobbiamo far funzionare correttamente il lettore **miniLector CIE** su Ubuntu Server, ricordando che quest’ultimo è installato su Raspberry Pi.

 

## 1. Requisiti

Vediamo quali sono i requisiti indispensabili per portare a termine l’attività d’installazione del lettore miniLector CIE.

- **Raspberry Pi 4** : è possibile utilizzare tutti i modelli della serie 4; personalmente ho utilizzato la versione con 8 GByte di memoria RAM e in particolare ho acquistato il [Melopero Raspberry Pi 4 Computer Official Premium Kit (8GB RAM, White)](https://amzn.to/3mGwVIF).
- **Sistema Operativo** : [Ubuntu Server 20.04.1 LTS](https://ubuntu.com/download/server/arm) per piattaforma **ARM**.
- Lettore [**miniLector CIE**](https://shop.bit4id.com/prodotto/minilector-cie/?utm_source=ref_blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1) acquistabile direttamente dal sito di [Bit4i](https://shop.bit4id.com/prodotto/minilector-cie/?utm_source=ref_blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1)d.
- **Connettività verso la rete internet**. Il Raspberry Pi deve poter accedere alla rete internet per scaricare tutto il software aggiuntivo necessario per installare correttamente il lettore di Smart Card.

Assumo che sul vostro Raspberry Pi sia installato e correttamente configurato il sistema operativo Ubuntu Server 20.04.1 LTS. Nel caso in cui non abbiate installato il sistema operativo sul vostro Raspberry Pi, consiglio di seguire l’ottimo tutorial [How to install Ubuntu Server on your Raspberry Pi](https://ubuntu.com/tutorials/how-to-install-ubuntu-on-your-raspberry-pi#1-overview), che in appena trenta minuti vi consentirà di avere Ubuntu Server installato e operativo sul vostro Raspberry Pi. La figura a seguire mostra il messaggio di benvenuto della mia installazione di Ubuntu Server sul mio Raspberry Pi 4.

 

[![Figura 2 - Messaggio di benvenuto di Ubuntu Server all'accesso sul Raspberry Pi 4](https://www.dontesta.it/wp-content/uploads/2020/11/ubuntu-server-20-lts-welcome-raspberry-pi-4.png "Figura 2 - Messaggio di benvenuto di Ubuntu Server all'accesso sul Raspberry Pi 4")](https://www.dontesta.it/wp-content/uploads/2020/11/ubuntu-server-20-lts-welcome-raspberry-pi-4.png)

Figura 2 – Messaggio di benvenuto di Ubuntu Server all’accesso sul Raspberry Pi 4

 

## 2. I driver per lettori di Smart Card

Per quel che concerne il lettore di Smart Card, non sono richieste caratteristiche specifiche, è sufficiente che sia conforme allo standard internazionale [**PC/SC**](https://it.wikipedia.org/wiki/PC/SC)** (Personal Computer/Smart Card)**, utilizzabile sui sistemi operativi Windows, Mac OS e Linux/Unix, e alla  norma **[ISO 7816-3](https://it.wikipedia.org/wiki/ISO/IEC_7816)**. La caratteristica **fondamentale da prendere in considerazione** è il supporto per il protocollo standard **[CCID](https://en.wikipedia.org/wiki/CCID_(protocol)) (Chip Card Interface Device)**.

Dopo varie ricerche e confronti su lettori di Smart Card, la scelta è ricaduta sul lettore [**miniLector CIE**](https://shop.bit4id.com/prodotto/minilector-cie/?utm_source=ref_blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1), valutando anche la precedente positiva esperienza con il lettore  **[miniLector EVO Indoor USB 2.0](https://shop.bit4id.com/prodotto/minilector-evo/)** prodotto sempre da [Bit4id](https://www.bit4id.com/it/). Il lettore miniLector CIE rispecchia tutte le caratteristiche base sopra indicate, più il supporto allo standard CCID, fondamentale in particolare su ambienti Linux/Unix/Mac OS. Per maggiori informazioni su questo lettore, fate riferimento al [datasheet](https://www.bit4id.com/wp-content/uploads/2019/05/minilector_cie.pdf) (in formato PDF).

Con questo lettore di Smart Card sono forniti i [driver per i più comuni sistemi operativi](https://support.bit4id.com/#!/it/drivers/product/minilector_cie), il più delle volte sui sistemi operativi più recenti non è solitamente necessaria l’installazione dei driver forniti; il driver CCID nativo del sistema operativo è sufficiente.

**Perchè il nostro caso è leggermente differente?** I driver distribuiti con il lettore sono disponibili solo per piattaforme **x86** e **x86\_64** , abbiamo invece bisogno del driver CCID **per piattaforma ARM** e che **supporti il lettore miniLector CIE**.

Con il sistema operativo [Ubuntu Server 20.04.1 LTS](https://packages.ubuntu.com/) è distribuita la versione [1.4.31-1 (package libccid)](https://packages.ubuntu.com/focal/libccid) del driver CCID. Questa versione non supporta però il miniLector CIE. I dispositivi prodotti da Bit4id e supportati dalla versione 1.4.31 del driver CCID sono quelli indicati a seguire.

- miniLector-s
- cryptokey
- iAM
- CKey4
- tokenME FIPS v3
- Digital DNA Key
- Digital-DNA Key BT
- Digital-DNA Key
- TokenME EVO v2
- miniLector
- miniLector AIR EVO
- miniLector Blue

[Ludovic Rousseau](https://ludovicrousseau.blogspot.com/), autore e maintainer del driver CCID, definisce quattro classi per i lettori di Smart Card. Quelli prodotti da Bit4id rientrano nella categoria **Should work.**

1. [Supported](https://ccid.apdu.fr/ccid/supported.html) readers
2. [Should work](https://ccid.apdu.fr/ccid/shouldwork.html) readers
3. [Unsupported](https://ccid.apdu.fr/ccid/unsupported.html) readers
4. [Disabled](https://ccid.apdu.fr/ccid/disabled.html) readers

Visto che i driver distribuiti con il lettore sono disponibili solo per piattaforme x86 e x86\_64, **come possiamo fare per aggiungere il supporto al driver CCID distribuito con Ubuntu Server per questo specifico lettore?**

La soluzione è più semplice di quella che possiate immaginare e la risposta a questa domanda la vedremo nel corso dei prossimi capitoli. Quindi, riprendete la concentrazione e spostiamoci sui successivi capitoli.

 

## 3. Come aggiungere il supporto al driver CCID per il miniLector CIE

Per raggiungere il nostro obiettivo dobbiamo procedere step-by-step.

1. Identificazione hardware del lettore miniLector CIE.
2. Abilitazione dei Source [Repository](https://wiki.ubuntu-it.org/Repository) di [Ubuntu Server (Focal Fossa)](https://wiki.ubuntu-it.org/Repository/SourcesList#Ubuntu_20.04_Focal_Fossa)
3. Preparazione directory di lavoro per la build della nuova versione del driver [libccid](https://packages.ubuntu.com/focal/libccid).
4. Installazione dei pacchetti necessari per la build del driver.
5. Preparazione dei sorgenti e applicazione della patch per aggiungere il supporto al lettore miniLector CIE.
6. Avvio del processo di build, installazione e verifica di funzionamento del nuovo driver.

 

Prima di andare avanti nell’esecuzione dei singoli step, avviamo il nostro Raspberry Pi e successivamente colleghiamo il lettore ad una delle porte USB disponibili. Con la console di Ubuntu Server operativa e davanti a noi siamo pronti per l’esecuzione degli step precedentemente indicati.

 

### 3.1 Identificazione del lettore miniLector CIE

L’identificazione del lettore è fondamentale per recuperare le informazioni necessarie che serviranno successivamente per applicare correttamente la patch alla versione attuale del driver CCID. Ogni componente hardware è per cosi dire **“battezzato”** , ha un proprio identificativo. Il comando [**lsusb**](https://manpages.ubuntu.com/manpages/focal/en/man8/lsusb.8.html) è quello che consentirà di recuperare le informazioni di nostro interesse.

 

[![Figura 3 - Identificazione lettore Smart Card tramite comando lsusb](https://www.dontesta.it/wp-content/uploads/2020/11/lsusb-command-for-retrieve-information-smart-card-reader-1024x336.png "Figura 3 - Identificazione lettore Smart Card tramite comando lsusb")](https://www.dontesta.it/wp-content/uploads/2020/11/lsusb-command-for-retrieve-information-smart-card-reader.png)

Figura 3 – Identificazione lettore Smart Card tramite comando lsusb

 

Dall’output del comando `lsusb -v -t`, siamo in grado d’identificare facilmente, anche grazie alla classe ( **Chip/SmartCard** ), il lettore miniLector CIE, il cui identificativo è **0x25dd** : **0x3403** , di cui, il primo identifica il vendor o produttore, che in questo caso è Bit4id, il secondo identifica invece lo specifico dispositivo. Le informazioni sul vendor o produttore e sull’identificativo del dispositivo, mettiamole da parte, queste saranno utili successivamente.

 

### 3.2 Abilitazione dei Source Repository

Penso sia chiaro il fatto che abbiamo bisogno dei sorgenti del driver CCID versione [1.4.31-1 (package libccid)](https://packages.ubuntu.com/focal/libccid). Per soddisfare questo requisito è sufficiente abilitare i Source Repository di Ubuntu Server 20.04.1 LTS (Focal Fossa), editando il file `/etc/apt/sources.list` e de-commentando la riga evidenziata dalla figura a seguire.

 

[![](https://www.dontesta.it/wp-content/uploads/2020/11/enable-soures-apt-ubunt-server-focal-fossa-1024x668.png "Figura 4 - Abilitazione Source per Ubuntu Server Focal Fossa (universe)")](https://www.dontesta.it/wp-content/uploads/2020/11/enable-soures-apt-ubunt-server-focal-fossa.png)

Figura 4 – Abilitazione Source per Ubuntu Server Focal Fossa (universe)

 

Una volta eseguita la modifica, occorre lanciare il comando `sudo apt update` affinché si aggiorni la cache locale anche per i source package. Possiamo fare una verifica che il package source relativo al driver CCID sia adesso disponibile utilizzando il comando `apt show source libccid`.

 

[![Figura 5 - Output del comando apt show source libccid](https://www.dontesta.it/wp-content/uploads/2020/11/output-command-apt-show-source-libccid-1024x741.png "Figura 5 - Output del comando apt show source libccid")](https://www.dontesta.it/wp-content/uploads/2020/11/output-command-apt-show-source-libccid.png)

Figura 5 – Output del comando apt show source libccid

 

### 3.3 Preparazione directory di lavoro

Una volta che ci siamo accertati della disponibilità del codice sorgente del driver CCID, possiamo preparare la directory di lavoro che useremo per produrre il nuovo driver che supporti il lettore miniLector CIE. Potremmo per esempio creare all’interno della propria home directory, la directory **ccid\_minilector\_cie** , utilizzando il comando `mkdir ~/ccid_minilector_cie`

 

### 3.4 Installazione pacchetti necessari alla build

Affinché sia possibile eseguire la build dei sorgenti del driver CCID, è necessario installare i package degli strumenti di sviluppo (autoconf, make, gcc, etc.). A seguire sono mostrati i gruppi di package da installare tramite il comando apt.

1. build-essential
2. devscripts

Il comando per installare i due package è `sudo apt install build-essential devscripts`.

 

### 3.5 Preparazione sorgenti e applicazione della patch al driver CCID

All’interno della nostra directory di lavoro (~/ccid\_minilector\_cie), occorre preparare i sorgenti del driver CCID per poi procedere con l’applicazione della patch che aggiungerà il supporto per il driver del lettore di Smart Card. Utilizzando il comando `apt source libccid`, saremo in grado di ottenere i sorgenti del driver. Ricordiamoci di eseguire il comando all’interno della nostra directory di lavoro. La figura a seguire mostra l’output che dovremmo ottenere dall’esecuzione del comando.

 

[![Figura 6 - Output del comando apt source libccid](https://www.dontesta.it/wp-content/uploads/2020/11/output-command-apt-source-libccid-1024x447.png "Figura 6 - Output del comando apt source libccid")](https://www.dontesta.it/wp-content/uploads/2020/11/output-command-apt-source-libccid.png)

Figura 6 – Output del comando apt source libccid

 

Al termine dell’esecuzione del comando indicato in precedenza, all’interno della directory di lavoro dovremmo trovare i seguenti elementi:

1. **ccid\_1.4.31-1.dsc**. Il file di testo che descrive il package del driver CCID;
2. **ccid\_1.4.31.orig.tar.bz2**. L’archivio che contiene i file sorgenti originali;
3. **ccid\_1.4.31-1.debian.tar.xz**. L’archivio che contiene i file specifici per Debian a cui sono applicate eventuali patch (vedi immagine precedente);
4. **ccid-1.4.31**. La directory contenente i file sorgenti del driver CCID predisposti con eventuale patch e per essere compilati con il sistema di build standard della distribuzione Debian.

**Cosa vuol dire applicare la patch ai sorgenti del driver CCID per aggiungere il supporto al miniLector CIE?** Vuol dire che dobbiamo recuperare le informazioni che identificano il lettore di Smart Card e aggiungere queste all’interno del file `readers/supported_readers.txt`. Questo file contiene la lista di tutti i dispositivi che dovrebbero funzionare correttamente con il driver CCID.

Per facilitare le operazioni, ho realizzato il cosiddetto [**patch file**](https://en.wikipedia.org/wiki/Patch_(Unix)), questo andrà applicato al file readers/supported\_readers.txt utilizzando il comando mostrato a seguire.

```
curl -s https://gist.githubusercontent.com/amusarra/265d952d9f47db355d5182a8bada3121/raw/87ae860c89e1a89043ec6127fc766c20a54d022f/BIT4ID_miniLector_AIR_NFC_v3.patch \
 | patch --verbose -b readers/supported_readers.txt
```

 

[![Figura 7 - Applicazione della patch tramite il comando patch](https://www.dontesta.it/wp-content/uploads/2020/11/apply-patch-to-driver-ccid-1024x265.png "Figura 7 - Applicazione della patch tramite il comando patch")](https://www.dontesta.it/wp-content/uploads/2020/11/apply-patch-to-driver-ccid.png)

Figura 7 – Applicazione della patch tramite il comando patch

 

L’applicazione della patch aggiungerà al file readers/supported\_readers.txt la riga seguente:

- 0x25DD:0x3403:BIT4ID miniLector AIR NFC v3

La riga è composta dall’identificativo del produttore, seguito dall’identificativo del dispositivo, a sua volta seguito dalla descrizione del dispositivo stesso; ma attenzione! **Perchè la descrizione del dispositivo non è miniLector CIE?** Perchè, miniLector CIE fa riferimento al nome commerciale, mentre **miniLector AIR NFC v3** , è il nome tecnico del dispositivo.

Adesso che la patch è stata applicata, è possibile procedere alla fase di build del driver CCID.

 

### 3.6 Build, installazione e verifica del nuovo driver CCID

Il risultato della build sarà il file del driver in formato [**deb**](https://en.wikipedia.org/wiki/Deb_(file_format)). Per avviare il processo di build eseguire il comando `debuild -b -uc -us` dalla directory ~/ccid\_minilector\_cie/ccid-1.4.31. Terminato il processo di build, otterremo il file del driver in formato deb (posizionato in ~/ccid\_minilector\_cie/). La figura a seguire mostra in evidenza il file **libccid\_1.4.31-1\_arm64.deb** del driver CCID in formato deb.

 

[![Figura 8 - Diver CCID in formato deb dopo il processo di build](https://www.dontesta.it/wp-content/uploads/2020/11/driver-ccid-after-build-1024x296.png "Figura 8 - Driver CCID in formato deb dopo il processo di build")](https://www.dontesta.it/wp-content/uploads/2020/11/driver-ccid-after-build.png)

Figura 8 – Driver CCID in formato deb dopo il processo di build

 

Utilizzando il comando `sudo dpkg -i libccid_1.4.31-1_arm64.deb`, installeremo il nuovo driver CCID. Adesso che il nuovo driver è stato installato, facciamo una verifica dell’installazione utilizzando il comando `apt show libccid`.

L’output mostrato a seguire indica che il driver è stato installato correttamente. Direi che siamo proprio a buon punto. Adesso possiamo procedere con la verifica che effettivamente il driver appena compilato ed installato funzioni a dovere.

 

[![Figura 9 - Verifica dell'installazione del nuovo driver CCID](https://www.dontesta.it/wp-content/uploads/2020/11/check-driver-ccid-after-installation-1024x842.png "Figura 9 - Verifica dell'installazione del nuovo driver CCID")](https://www.dontesta.it/wp-content/uploads/2020/11/check-driver-ccid-after-installation.png)

Figura 9 – Verifica dell’installazione del nuovo driver CCID

 

## 4. Test del lettore

Il driver è stato installato correttamente sul nostro Raspberry Pi, possiamo quindi verificare che il lettore venga visto correttamente dal sistema operativo ed eseguire anche un semplice test di lettura. Per l’operazione di test utilizzeremo i tool PC/SC che dobbiamo installare utilizzando il comando `sudo apt install pcsc-tools pcscd opensc`.

[**pcscd**](https://manpages.ubuntu.com/manpages/focal/en/man8/pcscd.8.html) è il programma demone per **pcsc-lite** e il framework **[MuscleCard](https://muscle.apdu.fr/musclecard.com/musclecard/index.html)**. È un gestore delle risorse che coordina le comunicazioni con lettori di Smart Card e Smart Card e Token Crittografici collegati al sistema. pcscd è normalmente avviato allo start-up del sistema operativo da `/etc/init.d/pcscd`. Consente alle applicazioni di accedere a Smart Card e lettori senza conoscere i dettagli implementativi di quest’ultimi. In ultimo pcscd coordina il caricamento dei driver per i lettori, è infatti responsabile del caricamento del driver per il lettore miniLector CIE (tecnicamente miniLector AIR NFC v3).

Lo scopo di pcsc-lite è fornire un’API cross-compatibile (chiamata winscard) per la migrazione di applicazioni basate su PC/SC da Windows a Unix.

Dopo questa brevissima overview su pcscd e pcsc-lite, utilizziamo il comando `opensc-tool -l` con lo scopo di vedere in output il miniLector CIE disponibile come lettore di Smart Card per il nostro Raspberry Pi. Fate attenzione al nome tecnico del dispositivo, **miniLector AIR DI v3** (vedi figura a seguire).

 

[![Figura 10 - Lista dei lettori di Smart Card connessi al Raspberry Pi](https://www.dontesta.it/wp-content/uploads/2020/11/opensc-tool-lists-smart-card-readers-1024x124.png "Figura 10 - Lista dei lettori di Smart Card connessi al Raspberry Pi")](https://www.dontesta.it/wp-content/uploads/2020/11/opensc-tool-lists-smart-card-readers.png)

Figura 10 – Lista dei lettori di Smart Card connessi al Raspberry Pi

 

L’esito positivo di questo test conferma che il driver su cui abbiamo applicato la patch e successivamente installato sul nostro Raspberry Pi, funziona correttamente. Da adesso in poi possiamo quindi utilizzare il lettore per leggere e scrivere Smart Card contact less.

Per lo scopo di questo articolo, abbiamo raggiunto il risultato atteso con successo. Desidero però lasciarvi con un esempio di lettura di una carta [**Mifare Classic 1K**](https://www.nxp.com/products/rfid-nfc/mifare-hf/mifare-classic:MC_41863), in particolare vediamo come leggere l’identificativo o seriale della carta. Per fare questa di lettura possiamo utilizzare il comando `opensc-tool -s "FF CA 00 00"`, il cui risultato è mostrato a seguire. I quattro byte **B4 90 90 1E** rappresentano il seriale della carta. I byte **FF CA 00 00** rappresentano invece l’[**APDU (Application Protocol Data Units)**](https://it.wikipedia.org/wiki/Application_Protocol_Data_Unit) che inviata al lettore, ci consente di ottenere l’informazione richiesta, che in questo caso è il seriale della carta.

 

[![Figura 11 - Lettura del seriale di una carta Mifare Classic 1K](https://www.dontesta.it/wp-content/uploads/2020/11/read-the-serial-of-the-mifare-classic-apdu-1024x147.png "Figura 11 - Lettura del seriale di una carta Mifare Classic 1K")](https://www.dontesta.it/wp-content/uploads/2020/11/read-the-serial-of-the-mifare-classic-apdu.png)

Figura 11 – Lettura del seriale di una carta Mifare Classic 1K

 

La figura a seguire mostra invece informazioni molto più interessanti riguardo il lettore e ciò che lo stesso sta leggendo. Queste informazioni sono state ottenute utilizzando il comando [**pcsc\_scan**](https://manpages.ubuntu.com/manpages/focal/en/man1/pcsc_scan.1.html).

 

[![Figura 12 - Output del comando PC/SC Scan](https://www.dontesta.it/wp-content/uploads/2020/11/output-pcsc_scan_command-1024x1125.png "Figura 12 - Output del comando PC/SC Scan")](https://www.dontesta.it/wp-content/uploads/2020/11/output-pcsc_scan_command.png)

Figura 12 – Output del comando PC/SC Scan

## 5. Risorse

A seguire sono disponibili delle risorse utili che sono anche il riferimento di questo articolo.

1. CCID free software driver – [https://ccid.apdu.fr/](https://ccid.apdu.fr/)
2. Smartcards (Debian) – [https://wiki.debian.org/Smartcards#libccid](https://wiki.debian.org/Smartcards#libccid)
3. Ludovic Rousseau’s blog – [https://ludovicrousseau.blogspot.com/](https://ludovicrousseau.blogspot.com/)
4. pyscard: smartcard library for python – [https://github.com/LudovicRousseau/pyscard](https://github.com/LudovicRousseau/pyscard)
5. Debian Building Tutorial – [https://wiki.debian.org/BuildingTutorial](https://wiki.debian.org/BuildingTutorial)
6. [Carta d’Identità Elettronica: come accedere ai servizi online con la CIE](https://blog.bit4id.com/carta-didentita-elettronica-come-accedere-ai-servizi-online-con-la-cie-parte-1/?utm_source=blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1)
7. [CIEfacile](https://shop.bit4id.com/soluzioni-per-la-carta-didentita-elettronica/?utm_source=blog&utm_medium=post&utm_campaign=ref_dontesta&utm_content=v1)

 

## 6. Conclusioni

Ho voluto scrivere quest’articolo come introduzione necessaria alla realizzazione dello scenario mostrato nel paragrafo iniziale (vedi Figura 1 – Possibile scenario d’integrazione Smart Card e Raspberry Pi). Aggiungere il supporto per questo lettore di Smart Card al driver CCID è stato abbastanza semplice, anche mantenendo lo standard di build adottato dai sistemi derivati da Debian, come appunto Ubuntu Server, che abbiamo usato come sistema operativo di riferimento.

Sono consapevole del fatto che il contenuto di questo articolo è fin troppo specifico, sono però certo del fatto che a qualcuno di voi potrebbe risultare utile o magari ha già dovuto affrontare questa situazione. In quest’ultimo caso mi piacerebbe sapere com’è stato affrontato il problema.

La procedura per il build del driver CCID dai sorgenti, può essere applicata in genere su tutti sistemi operativi derivati da Debian e Ubuntu è uno di quelli. La stessa procedura può quindi essere applicata sul sistema operativo Raspberry Pi OS (precedentemente Raspbian).

I campi di applicazione utilizzando la coppia Raspberry Pi e lettore di Smart Card sono innumerevoli, e quanto prima cercherò di uscire con l’articolo che vi mostrerà l’implementazione dello scenario presentato nel paragrafo iniziale. **Quali sono le idee che avete in mente o che avete realizzato con il Raspberry Pi e lettore di Smart Card?**

L'articolo [Raspberry Pi: Come installare il miniLector CIE su Ubuntu Server 20.04 LTS](https://www.dontesta.it/2020/11/04/raspberry-pi-come-installare-minilector-cie-ubuntu-server-20-04-lts/) sembra essere il primo su [Antonio Musarra's Blog](https://www.dontesta.it).

[![](http://feeds.feedburner.com/~ff/dontesta/blog?d=yIl2AUoC8zA)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:yIl2AUoC8zA) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=dnMXMwOfBR0)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:dnMXMwOfBR0) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=F7vd5xNkAk4:6l6DAk2HjM4:D7DqB2pKExk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:D7DqB2pKExk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=YwkR-u9nhCs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:YwkR-u9nhCs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=F7vd5xNkAk4:6l6DAk2HjM4:F7zBnMyn0Lo)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:F7zBnMyn0Lo) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=F7vd5xNkAk4:6l6DAk2HjM4:V_sGLiPBpWU)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:V_sGLiPBpWU) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=qj6IDK7rITs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:qj6IDK7rITs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=F7vd5xNkAk4:6l6DAk2HjM4:KwTdNBX3Jqk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:KwTdNBX3Jqk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=F7vd5xNkAk4:6l6DAk2HjM4:gIN9vFwOqvQ)](http://feeds.feedburner.com/~ff/dontesta/blog?a=F7vd5xNkAk4:6l6DAk2HjM4:gIN9vFwOqvQ)
 ![](http://feeds.feedburner.com/~r/dontesta/blog/~4/F7vd5xNkAk4)