|
|||||||||||||||||||||||||||||||||
Lo standard OpenCard è particolarmente importante per le JavaCard, poiché permette di realizzare la portabilità delle applicazioni che utilizzano JavaCard fra diversi tipi di JavaCard, completando la portabilità dei servizi fra diversi tipi di JavaCard, fiore all’occhiello dell’ambiente JavaCard. Questo permette agli sviluppatori di realizzare applicazioni basate su SmartCard astraendo dal tipo di SmartCard utilizzato. In generale, ogni tipo di SmartCard prevede meccanismi d’accesso e d’accesso ai servizi differenti: questo implica un legame piuttosto stretto fra l’applicazione che utilizza le SmartCard e il tipo delle SmartCard scelto. L’utilizzo dello standard OpenCard di OCF permette, invece, di svincolare l’applicazione dal particolare tipo di SmartCard scelto. In questo modo, un’applicazione può funzionare virtualmente con tutti i tipi di SmartCard e di lettori disponibili. |
|||||||||||||||||||||||||||||||||
Introduzione
Lo standard OpenCard è implementato tramite un framework, realizzato in Java, che espone un’interfaccia standard verso le applicazioni e un’interfaccia configurabile verso il driver di accesso al CAD (lettore delle SmartCard). Quest’ultima parte del framework è appunto quella che permette di accedere a tutti i tipi di CAD e di SmartCard. La standardizzazione dell’accesso ai servizi installati sulla SmartCard è invece realizzata dal resto del framework, che espone appositi metodi per l’accesso ai servizi. La scelta di realizzare l’intero framework utilizzando Java permette poi di utilizzare questo framework virtualmente su ogni piattaforma hardware e software, in modo conforme alla filosofia che anima il framework OpenCard stesso e l’ambiente JavaCard. Unico neo di questa scelta è, in realtà, una certa pesantezza del framework stesso, soprattutto rispetto ai semplici driver di accesso al CAD e alla SmartCard, che comunque devono continuare ad esistere per permettere il corretto funzionamento del framework OpenCard. In
quest’articolo sarà introdotto il framework OpenCard, concentrando
l’attenzione sulle funzionalità offerte e sui vantaggi che ne derivano
per l’utilizzo delle JavaCard. Nelle conclusioni saranno inoltre riportati
pregi e difetti di questo strumento.
OCF OpenCard
E’ importante sottolineare in primo luogo che quello che viene fornito da OCF con lo standard OpenCard non è propriamente un’implementazione completa di funzionalità per l’accesso alle SmartCard tramite lettori e ai servizi installati sulle SmartCard, ma piuttosto un framework, cioè un modello, costituito in buona parte da classi astratte e interfacce in grado di orientare i fornitori di CAD e di SmartCard ad un utilizzo standardizzato delle risorse. Questo permette agli sviluppatori che utilizzano le SmartCard di lavorare in maniera indipendente dal tipo di SmartCard e CAD utilizzati e dai dettagli organizzativi dei servizi installati. Il framework OpenCard è stato progettato avendo come obiettivo generale la sua applicabilità ad ambienti estremamente diversi fra loro. Per questo motivo il framework è scritto completamente in Java e tutte le informazioni di configurazione necessarie sono reperite inizialmente da parametri di sistema. Questo permette al framework di funzionare correttamente non solo su PC e workstation, ma anche su macchine dotate di hardware minimali, come macchine automatiche per l’accettazione di SmartCard o telefoni cellulari. Gli
obiettivi tecnici dichiarati dello standard OpenCard sono l’indipendenza
dal tipo di CAD (detto anche IFD, cioè InterFace Device) e l’indipendenza
dal tipo di sistema operativo installato sulla SmartCard (fonte dei servizi
resi disponibili dalla SmartCard). Questo viene ottenuto tramite l’implementazione
di due livelli denominati CardTerminal Layer e CardService Layer, come
riportato nella figura 1, che insieme compongono la struttura dello standard
OpenCard:
Nel proseguo dell’articolo verranno trattati questi due livelli, analizzandoli dal punto di vista dei loro ulteriori componenti e delle loro funzionalità. Per ulteriori informazioni di carattere generale si consulti [Ibm98a]. Di seguito viene descritto il CardTerminal Layer, cioè la parte dello standard OpenCard dedicata alla standardizzazione dell’accesso alle SmartCard tramite il lettore. I compiti di questo livello sono di astrarre dall’implementazione della connessione al lettore e di uniformare i metodi di accesso alla SmartCard. Il CardTerminal Layer, basato sulla classe CardTerminal, è realizzato tramite l’implementazione di API Java addette all’accesso alle SmartCard tramite i lettori da parte dell’entità esterna. I servizi forniti da questo livello sono principalmente la notifica tramite eventi dell’inserimento di SmartCard all’interno dei lettori, la standardizzazione della procedura di verifica del PIN della carta, la standardizzazione dei metodi di invio di APDU di comando e di ricezione di APDU di risposta. Questo livello fornisce anche il supporto per la gestione degli slot, cioè delle postazione multiple messe a disposizione da certi lettori. Questo tipo di lettori fornisce la possibilità di connettere diverse SmartCard ad una stessa interfaccia, pur mantenendoli distinguibili dal punto di vista del software che le accede. Naturalmente, un livello di questo tipo deve comunque basarsi su un ulteriore livello che astrae dall’hardware sottostante. Questo viene realizzato applicando le regole definite dall’abstract factory pattern e dal singleton pattern. Queste regole prevedono la fornitura, da parte dei produttori dei lettori, di una classe CardTerminalFactory per ogni tipo di lettore, che permette la creazione di oggetti specifici in grado di fornire le funzionalità di basso livello richieste alla classe CardTerminal. Le informazioni relative a tutte le coppie di oggetti delle classi CardTerminal e CardTerminalFactory installati nell’entità esterna sono mantenute da un oggetto della classe CardTerminalRegistry, che mantiene inoltre tutte le informazioni di configurazione necessarie per un corretto funzionamento. Quest’oggetto permette due tipi di configurazione, in funzione del tipo di collegamento utilizzato fra entità esterna e lettore: una di tipo statico, basata sulla conoscenza a priori della configurazione dei lettori collegati all’entità esterna, e una di tipo dinamico, che permette il collegamento a runtime di ulteriori lettori all’entità esterna tramite metodi di registrazione e di deregistrazione. Quest’ultimo caso è tipico del collegamento di lettori a porte fisiche che permettono il collegamento dinamico di periferiche (per esempio USB e PCMCIA). Scendendo
ancor più in dettaglio, è necessario precisare che la classe
CardTerminal è in realtà una classe astratta da cui derivano
le classi effettivamente istanziabili, funzione del tipo di lettore ad
alto livello, per la creazione di oggetti di controllo. Questi oggetti
contengono in generale diversi oggetti della classe Slot, che rappresentano
una connessione virtuale verso una delle SmartCard attualmente inserite
nel lettore.
L’inserimento
o l’estrazione di una SmartCard da un lettore provoca, secondo lo standard
OpenCard, l’invio di un’eccezione specifica dall’oggetto CardTerminal all’oggetto
CardTerminalRegistry. Quest’ultimo provvede successivamente a notificare
l’accaduto, sempre tramite un’eccezione specifica, a tutti gli altri oggetti
CardTerminal e ai rispettivi oggetti CardTerminalFactory registrati. La
figura 3 mostra questo comportamento.
Notare che un comportamento del genere non è invece previsto per la registrazione o la deregistrazione di un oggetto CardTerminal, in quest’ultimo caso il comportamento di default è di non generare eccezioni. Per ulteriori informazioni si consulti [Ibm98b]. Passiamo ora alla descrizione del CardService Layer, cioè della parte dello standard OpenCard dedicata alla standardizzazione dell’accesso ai servizi messi a disposizione dalla SmartCard. In questo caso, l’obiettivo è la realizzazione dell’indipendenza dal produttore del sistema operativo della SmartCard. Questo viene ottenuto standardizzando, sia come denominazione sia come interfaccia verso l’entità esterna, tutti i servizi virtualmente presenti su una SmartCard. Attualmente è stato individuato e standardizzato un numero ridotto di servizi, ma OCF sta incrementando continuamente il numero di questi servizi, con l’obiettivo di standardizzare ogni possibile servizio utilizzabile su una SmartCard. Il
CardService Layer, come il CardTerminal Layer, è realizzato tramite
API Java. I servizi attualmente forniti da questo livello sono, fra gli
altri, l’accesso standardizzato ai file system contenuti sulla SmartCard,
l’accesso standardizzato alle funzionalità di firma offerte dalla
SmartCard e la standardizzazione delle funzionalità di identificazione,
selezione e controllo dei servizi correntemente caricati sulla SmartCard.
Quest’ultimo punto è molto importante dal punto di vista dell’astrazione
e della fruibilità dei servizi e si basa sulla realizzazione di
interfacce standard per:
Conclusioni
- indipendenza delle applicazioni o delle Applet dal tipo delle JavaCard utilizzate; - possibilità di utilizzare un unico sistema di accesso per tutte le JavaCard; - possibilità di rendere effettivamente portabili fra diverse piattaforme le applicazioni e le Applet sviluppate. Il rovescio della medaglia è dato principalmente dalla presenza di un framework riconfigurabile che funziona da interfaccia fra l’applicazione ed il lettore di SmartCard, e quindi la SmartCard stessa. Questo significa: - aumento del consumo di risorse per l’accesso alla JavaCard; - necessità di formazione per l’utilizzo del framework (strumento molto generico e quindi piuttosto ostico); - dipendenza dell’affidabilità complessiva dalle classi di interfaccia sviluppate dal produttore del lettore. In
realtà, nella maggior parte dei casi i vantaggi sono decisamente
prevalenti sugli svantaggi. I soli casi in cui può non essere conveniente
l’utilizzo del framework OpenCard sono alcune applicazioni che necessitano
di prestazioni elevate.
Bibliografia
[Ibm98a]: IBM, “OpenCard Framework General Information Web Document – Second Edition”, 1998 [Ibm98b]:
IBM, “OpenCard Framework 1.1 Programmer's Guide – Second Edition”, 1998
Conclusioni
Bibliografia
Roberto Fabbrica, nato a Ravenna il 28 dicembre 1972, è laureato in Ingegneria Informatica alla Facoltà di Ingegneria dell’Università di Bologna dal 1999. Attualmente lavora come libero professionista, fornendo consulenze come analista programmatore in Visual Basic ad una software house bolognese e collaborando al progetto e all’implementazione di applicazioni Java presso il DEIS (Dipartimento di Elettronica, Informatica e Sistemistica) della Facoltà di Ingegneria dell’Università di Bologna, sede di Cesena. |
|||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||
|