Raspberry Pi – Un esempio di applicazione della TS-CNS
Tags: blog, programming, cns, python
Published: 2020-09-10 21:17:40

---
title: Raspberry Pi – Un esempio di applicazione della TS-CNS
published: true
date: 2020-07-17 08:37:43 UTC
tags: Blog,Programming,CNS,Python
canonical_url: https://www.dontesta.it/2020/07/17/raspberry-pi-esempio-applicazione-ts-cns-smartcard/
---

Per il ponte del due giugno ho racimolato qualche “pezzo di ferro” e realizzato con il **Raspberry Pi** un piccolo progetto che prevede l’uso di un lettore di **Smart Card** e di altri componenti.

L’idea alla base della “ricetta” è quella di realizzare un sistema di sicurezza tale per cui è possibile attivare una serie di relè solo dopo che l’utilizzatore del sistema esegua con successo l’autenticazione tramite la propria **TS-CNS (Tessera Sanitaria – Carta Nazionale dei Servizi)**. Sul sito dell’[Agenzia per l’Italia digitale (AgID)](https://www.agid.gov.it/it/piattaforme/carta-nazionale-servizi) sono pubblicate tutte le informazioni di dettaglio sulla Carta Nazionale dei Servizi.

Nel corso di questo articolo vi mostrerò come ho realizzato il progetto, sia dal punto di vista hardware sia dal punto di vista software. Se siete impazienti di vedere il risultato ottenuto, vi invito a vedere il video [Un sistema di accesso basato sulla Smart Card TS-CNS e Raspberry Pi](https://youtu.be/_lOdD6tjSDo) che ho pubblicato sul mio canale YouTube.

<iframe width="560" height="315" src="https://www.youtube.com/embed/_lOdD6tjSDo" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="allowfullscreen"></iframe>

Questo progetto nasce dalla composizione dei seguenti “pezzi di ferro”.

1. [Raspberry Pi 3 Model B+](https://amzn.to/3h8RH0Z)
2. [Display LCD 16×2](https://amzn.to/2KRkiK5)
3. [Modulo quattro relè](https://amzn.to/3b2zpLc)
4. [KeyPad 16 caratteri (4×4)](https://amzn.to/3fwJnrr)
5. [Lettore Smart Card Bit4id](https://amzn.to/3ewS3N5)

Recentemente ho utilizzato il display LCD e il modulo da quattro relè nel progetto [Un primo maggio 2020 a base di Raspberry Pi, Bot Telegram, Display LCD e Relè](https://bit.ly/UnPrimoMaggio2020ABaseDiRaspberryPiBotTelegramDisplayLCDRele) che vi invito a leggere. Quelli che vedete nella figura a seguire sono i componenti utilizzati per la realizzazione del progetto (a meno della tastiera).

 ![Figura 1 - Vista dei componenti hardware utilizzati per la realizzazione del progetto](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/raw/master/docs/images/pezzi_di_ferro_progetto.jpeg "Figura 1 - Vista dei componenti hardware utilizzati per la realizzazione del progetto")

Figura 1 – Vista dei componenti hardware utilizzati per la realizzazione del progetto

## 1. Schema elettrico della soluzione

Dando per scontato che abbiate tutto il materiale hardware a vostra disposizione (vedi capitolo 2. Requisiti), possiamo disporre tutti collegamenti tra i vari componenti hardware che compongono la soluzione, così come indicato dallo schema elettrico mostrato a seguire.

Al fine di facilitare i collegamenti ho indicato nelle note quali sono i pin ( **BCM** ) che ogni componente utilizzerà. Per quanto riguarda il layout del connettore J8 del Raspberry Pi, fate riferimento alla documentazione ufficiale su [GPIO (general-purpose input/output)](https://www.raspberrypi.org/documentation/usage/gpio/).

 ![Figura 2 - Schema elettrico della soluzione](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/raw/master/docs/images/fritzing_schema_soluzione.png "Figura 2 - Schema elettrico della soluzione")

Figura 2 – Schema elettrico della soluzione

## 2. Requisiti

Per raggiungere l’obiettivo abbiamo bisogno di raccogliere un pochino di materiale, dobbiamo fare una sorta di lista della spesa, sia in termini hardware, sia in termini software. Partiamo dal basso, con la lista dell’hardware.

1. [**Raspberry Pi**](https://amzn.to/2KX1ybU): ho utilizzato la versione 3 Model B+ che sarà il riferimento di questo articolo. Per coloro che hanno a disposizione il [Raspberry Pi 2](https://amzn.to/35rsKJf) o il [Raspberry Pi 4](https://amzn.to/35vh4FE), non dovrebbe essere un problema.
2. [**Modulo Relè**](https://amzn.to/3b2zpLc): ho utilizzato il modello **Elegoo 4 Channel DC 5V Modulo Relay con accoppiatore ottico**. A quanto pare è difficile trovare questo modello, al suo posto, anche su Amazon, è stato sostituito con il modulo da otto. In ogni caso per questo esperimento va benissimo anche il modulo con due o al peggio un solo Relè.
3. [**Display LCD**](https://amzn.to/2KRkiK5): ho utilizzato un display LCD I2C 1602 16X2.
4. [**KeyPad 16 caratteri (4×4)**](https://amzn.to/2V5UgIg): ho scelto questo tastierino con lettere e caratteri “speciali” per il motivo che vedremo dopo.
5. [**Breadboard**](https://amzn.to/2SsrX5t), [**GPIO Extender**](https://amzn.to/3fd8eRa), [**Cavi Maschio a Femmina Dupont**](https://amzn.to/3bYFo5b) e [**Cavi Maschio a Maschio Dupont**](https://amzn.to/3drg1c7) utilizzati per realizzare i collegamenti tra il Raspberry Pi, il modulo LCD, il modulo Relè e il KeyPad.

Tutti i componenti hardware possono essere acquisitati separatamente, però, se l’argomento vi appassiona, consiglio l’acquisito dello **Starter Kit Freenove RFID per Raspberry Pi**. All’interno del kit sono inclusi gli ultimi elementi della nostra lista, oltre ad altri numerosi componenti.

Per quanto riguarda il software abbiamo bisogno di:

1. [**Raspbian OS**](https://www.raspberrypi.org/downloads/raspbian/): a meno di applicazioni particolari, questo sistema operativo basato su Debian è ottimizzato per la piattaforma Raspberry Pi. L’ultima versione disponibile è  **Raspbian Buster**. Sul mio Raspberry Pi 3 B+ ho installato quest’ultima release. Per maggiori informazioni sull’installazione del sistema operativo, fare riferimento alla guida ufficiale ([Installing operating system images](https://www.raspberrypi.org/documentation/installation/installing-images/README.md)). Questo sarà comunque il sistema operativo di riferimento.
2. **Python 3.x** : sul mio Raspberry Pi ho installato sia la versione 2.7 (quella di default) sia la versione 3.7, quest’ultima disponibile OOTB con l’ultima versione di Raspbian OS.
3. [**pad4pi**](https://pypi.org/project/pad4pi/): modulo Python per la gestione del KeyPad.
4. **Moduli software display LCD** : moduli Python per utilizzare il display LCD. Utilizzeremo i moduli scritti da [Freenove](http://www.freenove.com/) e reperibili dal loro repository [GitHub](https://github.com/Freenove/Freenove_Ultimate_Starter_Kit_for_Raspberry_Pi).
5. **PC/SC Middleware** : Middleware per la gestione e comunicazione per le Smart Card e Smart Card Reader.
6. [**OpenSC**](https://github.com/OpenSC/OpenSC/wiki): OpenSC fornisce una serie di librerie e utilità per lavorare con le Smart Card. Il suo focus principale è sulle schede che supportano le operazioni crittografiche e ne facilitano l’uso in applicazioni di sicurezza come l’autenticazione, la crittografia della posta e le firme digitali. OpenSC implementa le API standard su Smart Card, ad es. API **PKCS#11** , **Minidriver** per Smart Card di Windows e macOS **CryptoTokenKit**.

Possiamo verificare che il software attualmente installato sia conforme ai requisiti accedendo alla console del Raspberry Pi ed eseguendo i comandi a seguire.

```
# Verifica della Release del Sistema Operativo $ cat /etc/os-release # Verifica della Release del Kernel$ uname -a
```

A seguire è mostrato l’output dei comandi precedenti eseguiti sul mio Raspberry Pi.

```
# Output del comando cat /etc/os-releasePRETTY\_NAME="Raspbian GNU/Linux 10 (buster)"NAME="Raspbian GNU/Linux"VERSION\_ID="10"VERSION="10 (buster)"VERSION\_CODENAME=busterID=raspbianID\_LIKE=debianHOME\_URL="http://www.raspbian.org/"SUPPORT\_URL="http://www.raspbian.org/RaspbianForums"BUG\_REPORT\_URL="http://www.raspbian.org/RaspbianBugs" # Output del comando uname -aLinux amusarra-rpi 4.19.97-v7+ #1294 SMP Thu Jan 30 13:15:58 GMT 2020 armv7l GNU/Linux
```

Per quanto concerne la versione di Python, a meno di casi particolari, su Raspbian OS dovrebbero essere installate due release di Python, la 2.x e la 3.x. La specifica minor version dipende dalla versione del sistema operativo. Nel caso di Raspbian OS Buster le versioni esatte sono:

1. Python 2.7.16 (attiva per default)
2. Python 3.7.3

Sul mio Raspberry Pi ho reso di default la versione 3.7.3 di Python. Per rendere l’ultima versione di Python di default, è più che sufficiente aggiungere i seguenti alias su file ~/.bashrc

```
alias python='/usr/bin/python3'alias pip=pip3
```

Una volta concluse le verifiche che riguardano Python, possiamo passare all’installazione del resto dei componenti software.

```
$ sudo pip install pad4pi$ sudo apt-get install pcscd$ sudo apt-get install libccid$ sudo apt-get install opensc
```

A questo punto, che i requisiti hardware e software di base sono soddisfatti, vediamo com’è strutturato il progetto software.

## 3. Organizzazione del progetto

Il progetto software è stato realizzato in **Python** e tutto il codice sorgente è disponibile all’interno del repository GitHub [**amusarra/raspberry-pi-access-via-ts-cns**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns). La figura a seguire mostra il contenuto del repository di progetto.

 

[![Figura 3 - Repository GitHub raspberry-pi-access-via-ts-cns](https://www.dontesta.it/wp-content/uploads/2020/07/repository-github-raspberry-pi-access-via-ts-cns-1024x559.png "Figura 3 - Repository GitHub raspberry-pi-access-via-ts-cns")](https://www.dontesta.it/wp-content/uploads/2020/07/repository-github-raspberry-pi-access-via-ts-cns.png)

Figura 3 – Repository GitHub raspberry-pi-access-via-ts-cns

 

Il progetto è così organizzato:

1. **modules** : questa directory contiene i moduli Python per l’utilizzo del display LCD 16×2
  1. [PCF8574.py](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/modules/PCF8574.py): modulo per la gestione del bus i2c
  2. [Adafruit\_LCD1602.py](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/modules/Adafruit_LCD1602.py): funzioni ad alto livello per le operazioni sul display LCD
2. **scripts** : questa directory contiene lo script Python [**parse-gov-certs.py**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/scripts/parse-gov-certs.py) il cui scopo è il download dei certificati Governativi Italiani, e lo script bash [**auto-update-gov-certificates.sh**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/scripts/auto-update-gov-certificates.sh) il cui scopo è aggiungere sul sistema i certificati Governativi Italiani. Aggiungere questi certificati è fondamentale affinché il processo di validazione del certificato contenuto all’interno della TS-CNS trovi i certificati validi della catena di certificazione (o certificate path);
3. [**test\_keypad\_pin\_lcd.py**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/test_keypad_pin_lcd.py): script Python per il test del funzionamento del solo KeyPad;
4. [**verify\_ts\_cns\_pin.py**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/verify_ts_cns_pin.py): script Python per la verifica del codice PIN della TS-CNS;
5. [**activate\_relay\_via\_pin\_code.py**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/activate_relay_via_pin_code.py): script Python che permette l’attivazione dei relè inserendo il codice PIN (1234), senza quindi interazione con la TS-CNS;
6. [**activate\_relay\_via\_ts\_cns\_pin.py**](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/blob/master/activate_relay_via_ts_cns_pin.py): script Python che permette l’attivazione dei relè inserendo il codice PIN della TS-CNS.

 

Gli script  **verify\_ts\_cns\_pin.py**  e  **activate\_relay\_via\_ts\_cns\_pin.py** sono quelli che interagiscono con il lettore di Smart Card e la TS-CNS. Il resto degli script sono stati realizzati con il solo scopo di verificare la corretta funzionalità del KeyPad e del modulo Relè, e accertarsi quindi che i collegamenti tra i vari componenti stiano funzionando correttamente.

Cerchiamo adesso di capire insieme quali sono i punti importarti dello script **activate\_relay\_via\_ts\_cns\_pin.py** che permettono la verifica del codice PIN e del certificato digitale della TS-CNS.

Quella a seguire è la definizione della funzione **check\_pin(key)**. Questa funzione è responsabile della verifica del codice PIN immesso tramite il KeyPad. La verifica del codice PIN è eseguita utilizzando direttamente il tool **pkcs11-tool**. Ricordo che questo tool fa parte del pacchetto d’installazione di **OpenSC** (che abbiamo installato in precedenza).

 

```
# Check entered PIN codedef check\_pin(key): global entered\_pin command\_to\_check\_pin\_cns = "pkcs11-tool --login --test --verbose --pin " + entered\_pin if len(entered\_pin) >= 8 or key == "#": lcd.clear() lcd.message("Check PIN CNS...\n") p = subprocess.Popen(command\_to\_check\_pin\_cns, shell=True, stdout=subprocess.PIPE) (output, err) = p.communicate() p\_status = p.wait() print("Check PIN: ", output) if p\_status == 0: correct\_pin\_entered() if validate\_client\_certificate(): select\_relay\_to\_activate() else: incorrect\_pin\_entered()
```

 

Quella a seguire è invece la definizione della funzione **validate\_client\_certificate** , responsabile della validazione del certificato digitale contenuto all’interno della TS-CNS. Ricordo che il certificato digitale è rilasciato specificatamente al proprietario della TS-CNS. La verifica del certificato è realizzata attraverso l’uso del tool **pkcs15-tool** (che fa parte di OpenSC) e del tool **OpenSSL**.

 

```
# Validate the client certificatedef validate\_client\_certificate(): command\_to\_validate\_certificate = "pkcs15-tool -v -r 01|openssl verify" lcd.clear() lcd.message("Check CNS Cert..\n") p = subprocess.Popen(command\_to\_validate\_certificate, shell=True, stdout=subprocess.PIPE) (output, err) = p.communicate() p\_status = p.wait() print("Check Client Certificate: ", output) if p\_status == 0: print("TS-CNS Client Certificate validation passed") lcd.message("Passed") return True else: print("TS-CNS Client Certificate validation failed") lcd.message("Failed") return False
```

 

Per la semplicità del progetto ho preferito utilizzare direttamente i tool messi a disposizione da OpenSC. In contesti più complessi, dove magari è richiesto un maggior controllo sul lettore e sulla Smart Card, è possibile pensare (restando in Python) all’uso di [**pyscard – Python for Smart Cards**](https://pyscard.sourceforge.io/index.html).

## 4. Quick Start

Supponendo che abbiate montato tutto secondo lo schema elettrico indicato e che il vostro Raspberry Pi sia connesso alla rete internet, possiamo procedere con i seguenti step.

1. Accesso al Raspberry Pi via SSH o direttamente dal console. Consiglio di accedere e operare con utenza diversa da root.
2. Clonazione del repository [amusarra/raspberry-pi-access-via-ts-cns](https://github.com/amusarra/raspberry-pi-access-via-ts-cns).
3. Aggiornamento dei certificati di sistema.
4. Esecuzione del test di accesso e attivazione relè.

 

```
$ cd --$ git clone https://github.com/amusarra/raspberry-pi-access-via-ts-cns.git$ cd raspberry-pi-access-via-ts-cns$ cd scripts$ sudo ./auto-update-gov-certificate.sh
```

 

La figura a seguire mostra l’output che dovreste ottenere eseguendo lo script **auto-update-gov-certificates.sh** che aggiunge i certificati Governativi Italiani al sistema.

 

 ![Figura 4 - Output che si ottiene eseguendo lo script che aggiunge i certificati Governativi Italiani al sistema.](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/raw/master/docs/images/auto_update_gov_certificate.png "Figura 4 - Output che si ottiene eseguendo lo script che aggiunge i certificati Governativi Italiani al sistema.")

Figura 4 – Output che si ottiene eseguendo lo script che aggiunge i certificati Governativi Italiani al sistema.

 

L’aggiunta dei certificati Governativi Italiani al sistema è importante ai fini della validazione del certificato digitale presente sulla TS-CNS. Nel caso questa operazione non venisse eseguita, il processo di autenticazione non andrà mai a buon fine, anche nel caso in cui il PIN inserito fosse corretto.

 

 ![Figura 5 - Mostra il fallimento della validazione del certificato qualora i certificati di sistema non fossero aggiornati con quelli Governativi](https://github.com/amusarra/raspberry-pi-access-via-ts-cns/raw/master/docs/images/errore_validazione_certificato_1.png "Figura 5 - Mostra il fallimento della validazione del certificato qualora i certificati di sistema non fossero aggiornati con quelli Governativi")

Figura 5 – Mostra il fallimento della validazione del certificato qualora i certificati di sistema non fossero aggiornati con quelli Governativi

 

A questo punto è tutto pronto per iniziare i test di funzionamento della soluzione. Consiglio di procedere con l’esecuzione degli script Python, con lo stesso ordine mostrato nel capitolo _3. Organizzazione del progetto_. Per eseguire gli script sarà sufficiente utilizzare la sintassi `./nome_script_python.py`.

 

La figura a seguire mostra l’esecuzione e l’output dello script  **verify\_ts\_cns\_pin.py** che in questo caso evidenzia l’errato inserimento del codice PIN e di conseguenza l’accesso per l’attivazione dei relè non è consentito.

 

[![Figura 6 - Esempio di output dello script che verifica il PIN sulla TS-CNS](https://www.dontesta.it/wp-content/uploads/2020/07/output_verify_ts_cns_pin.png "Figura 6 - Esempio di output dello script che verifica il PIN sulla TS-CNS")](https://www.dontesta.it/wp-content/uploads/2020/07/output_verify_ts_cns_pin.png)

Figura 6 – Esempio di output dello script che verifica il PIN sulla TS-CNS

 

Le figure a seguire mostrano invece le varie fasi del processo di autenticazione: inserimento del PIN, validazione PIN e certificato digitale, accesso per l’attivazione dei quattro relè tramite il KeyPad.

 

[![Figura 7 - Richiesta inserimento PIN della TS-CNS](https://www.dontesta.it/wp-content/uploads/2020/07/request_enter_pin_of_the_ts_cns-1024x768.jpg "Figura 7 - Richiesta inserimento PIN della TS-CNS")](https://www.dontesta.it/wp-content/uploads/2020/07/request_enter_pin_of_the_ts_cns-scaled.jpg)

Figura 7 – Richiesta inserimento PIN della TS-CNS

 

[![Figura 8 - Controllo del PIN e Certificato Digitale avvenuto con successo](https://www.dontesta.it/wp-content/uploads/2020/07/access_granted_after_enter_pin_of_the_ts_cns-1024x768.jpg "Figura 8 - Controllo del PIN della TS-CNS avvenuto con successo")](https://www.dontesta.it/wp-content/uploads/2020/07/access_granted_after_enter_pin_of_the_ts_cns-scaled.jpg)

Figura 8 – Controllo del PIN della TS-CNS avvenuto con successo

 

[![Figura 9 - Attivazione dei relè dopo l'accesso](https://www.dontesta.it/wp-content/uploads/2020/07/activate_relay_after_access_granted_by_ts_cns-1024x768.jpg "Figura 9 - Attivazione dei relè dopo l'accesso")](https://www.dontesta.it/wp-content/uploads/2020/07/activate_relay_after_access_granted_by_ts_cns-scaled.jpg)

Figura 9 – Attivazione dei relè dopo l’accesso

## 5. Conclusioni

Questo è l’articolo che va a completare il video tutorial [Un sistema di accesso basato sulla Smart Card TS-CNS e Raspberry Pi](https://youtu.be/_lOdD6tjSDo) pubblicato sul mio canale YouTube verso la fine del mese di giugno.

In questo articolo abbiamo avuto modo di vedere quello che si può realizzare con un Raspberry Pi, un lettore di Smart Card, un KeyPad 4×4, un modulo da quattro relè, un display LCD 16×2 e la propria **TS-CNS (Tessera Sanitaria – Carta Nazionale dei Servizi)**.

Spero di aver acceso la tua fantasia per realizzare idee simili a quella che abbiamo appena vista insieme. Se ti fa piacere condividi pure attraverso i commenti, le possibili idee che questo articolo hanno scatenato.

L'articolo [Raspberry Pi – Un esempio di applicazione della TS-CNS](https://www.dontesta.it/2020/07/17/raspberry-pi-esempio-applicazione-ts-cns-smartcard/) 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=0tNjVUtAfTg:TItm1JnXiRI:yIl2AUoC8zA) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=dnMXMwOfBR0)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:dnMXMwOfBR0) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=0tNjVUtAfTg:TItm1JnXiRI:D7DqB2pKExk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:D7DqB2pKExk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=YwkR-u9nhCs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:YwkR-u9nhCs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=0tNjVUtAfTg:TItm1JnXiRI:F7zBnMyn0Lo)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:F7zBnMyn0Lo) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=0tNjVUtAfTg:TItm1JnXiRI:V_sGLiPBpWU)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:V_sGLiPBpWU) [![](http://feeds.feedburner.com/~ff/dontesta/blog?d=qj6IDK7rITs)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:qj6IDK7rITs) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=0tNjVUtAfTg:TItm1JnXiRI:KwTdNBX3Jqk)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:KwTdNBX3Jqk) [![](http://feeds.feedburner.com/~ff/dontesta/blog?i=0tNjVUtAfTg:TItm1JnXiRI:gIN9vFwOqvQ)](http://feeds.feedburner.com/~ff/dontesta/blog?a=0tNjVUtAfTg:TItm1JnXiRI:gIN9vFwOqvQ)
 ![](http://feeds.feedburner.com/~r/dontesta/blog/~4/0tNjVUtAfTg)