Il kit di simulazione della Java Card

In questa appendice si mostra il funzionamento del 'JavaCard Kit 2.2' [3],

descrivendo alcuni dei suoi comandi e spiegando come deve essere scrit-ta un'applet per essere messa in esecuzione su una Java Card [11,15,16].

Scrittura del codice sorgente

Vediamo prima di tutto un esempio per ricordare alcune regole per la programmazione in Java e poi mostreremo come deve essere scritta una applet per Java Card.

Un sorgente Java

Prima di tutto illustriamo la struttura del sorgente Java:

package pluto;

import paperone.banca;

import pippo.*;

public class Prova

public short metodo2 (short c)

Ricapitoliamo alcune regole di Java:

Ad ogni classe deve corrispondere un file *.java (non è previsto scrivere più di una classe per ogni file sorgente).

Il nome del file sorgente deve essere quello della classe con esten-sione .java, in questo esempio si dovrà chiamare Provjav

La direttiva package specifica che quella classe fa parte di un package (in questo caso il nome del package è 'pluto'). Un package non è altro che un contenitore per classi. Il sorgente ed il file .class, che si ottiene dopo la compilazione, devono trovarsi dentro una directory con lo stesso nome del package. Nel nostro esempio i file Provjava e Provclass devono stare nella directory di nome pluto.

Negli import si devono indicare i nomi delle classi usate da Prova, comprensivi del loro package; ovvero: nomepackage.nomeclasse.

Una applet per Java Card

Lo 'scheletro' di un'applet per Java Card è il seguente :

package pluto;

import paperone.Banca;

import pippo.*;

import javacard.framework.*

public class AppletProva extends Applet

public static void install(byte[] bArray,

short bOffset, byte bLenght)

public boolean select()

public boolean deselect()

public void process(APDU apdu) throws ISOException

private void metodol(APDU apdu)

private void metodo2(APDU apdu)

Il primo passo da fare è l'installazione dell'applet sulla Java Card. A questo fine chiamerà il metodo install(), che ha il compito di creare una istanza dell'applet invocando il costruttore AppletProva(). Quest'ultimo a sua volta si preoccuperà di effettuare la registrazione chiamando il metodo register().

Quando sarà il momento di utilizzare l'applet AppletProva, il JCRE deve

deselezionare l'applet corrente (chiamando la deselect() di quell'applet) e

selezionare AppletProva invocando il suo metodo select().

A questo punto il JCRE invocherà il metodo process(apdu) passando l'APDU che ci interess Al termine dell'esecuzione se tutto è andato bene viene riportato lo status word (SW) Ox9000.

Compilazione col comando javac

Supponiamo di aver scritto per esteso il codice di AppletProva e di averlo salvato nella directory C:esempio insieme a tutti i package di cui ha biso-gno.

Per compilare il codice della classe AppletProva si esegue il comando:

C:esempi> javac -g -classpath .; api.jar  

plutoAppletProvjava

L'opzione -g è fondamentale per poter in seguito generare un CAP file.

L'opzione -classpath serve per indicare al compilatore il cammino dove trovare tutti i package importati da AppletProvjava (in questo caso 'pippo' e 'paperone' si trovano nella stessa directory di 'pluto', altrimenti si deve specificare il percorso in cui si trovano) .

Il file api.jar è fondamentale per far riconoscere il pacchetto java-card.framework e quindi è necessario specificare il corretto percorso in cui è situato. Come si vede nell'esempio, i percorsi differenti in cui si trovano i vari package devono essere indicati separandoli con un ' ; ' .

Il comando converter

Supponiamo di aver scritto tutte le classi che fanno parte del package 'pluto' e di averle compilate. A questo punto non rimane che creare il CAP file del package 'pluto', per poter installare il package sulla cart A questo scopo è dedicato il comando converter.

Prima di usare converter, occorre creare un file .opt, un file di testo che

contiene alcune informazioni necessarie all 'esecuzione del comando.

Una volta creato il file AppletProvopt, è possibile eseguire il comando

converter:

converter -config plutoAppletProvopt

Al momento dell'esecuzione del comando, all'interno del package viene creata una directory di nome 'javacard'. Questa conterrà i file Applet-Provexp, AppletProvjca e AppletProvcap.

Comandi per verificare i file

I file .cap e .exp devono essere verificati prima di essere eseguiti dalla JCVM.

Per verificare il file .cap si usa il comando:

verifycap [opzioni]   <export file> <cap file>

In <export file> devono essere riportati gli export file di tutti i package usati dal CAP file da verificare. In particolare, saranno presenti gli export file delle API del javacard framework. Oltre ad essi si dovranno specificare sia gli export file degli altri package utilizzati dal CAP file sia l'export file relativo al CAP file stesso.

In <cap file> si deve indicare il CAP file da verificare.

Vediamo un esempio di come dovrebbe essere eseguito il comando verifycap:

C:esempio> verifycap . . .api-export-file;

javacardlang.exp;javacardframework.exp;

javacardcrypto.exp;javacardsecurity.exp;

<altri export file>;plutojavacardAppletProvexp

plutojavacardAppletProvcap

Precedentemente alla verifica del CAP file è opportuno controllare che siano corretti gli export file di cui si ha bisogno.

A questo scopo si usa il comando verifyexp come illustrato di seguito:

C:esempio> verifyexp plutojavacardAppletProvexp

Un altro comando che esegue dei controlli di compatibilità sugli export

file è il comando verifyrev:

C:esempio> verifyrev <lst export file> <2nd export

file>

Per verificare la compatibilità fra due versioni successive del solito export

file, si devono avere file con lo stesso nome ma percorsi diversi.

5 Il comando capgen

Il comando capgen viene usato per convertire un file scritto in formato JCA (Java Card Assembly) in file CAP. Un file JCA non è altro che un file di testo che contiene il bytecode dei metodi definiti in un package, più altre

informazioni sul package stesso.

Vediamo un esempio:

C:esempio> capgen -o. . .AppletProvcap

. . .AppletProvjca

Si genera il file AppletProvcap dal file AppletProvjc

L'opzione -o specifica il nome del file da creare comprensivo del percorso.

6 Uso del simulatore di Java Card

Una volta generato il CAP file, contenente una o più applet, è possibile installare tale file sul simulatore della Java Card e successivamente inviare delle APDU all'applet ed analizzarne le risposte.

Il simulatore si compone di tre programmi differenti:

cref : il simulatore vero e proprio;

scriptgen : programma che genera automaticamente lo script per l'installazione delle applet sul simulatore;

apdutool : programma che invia le APDU al cref usando gli script.

Il comando cref

La sintassi del comando è la seguente:

cref [opzioni]

Alcune delle opzioni più utili sono -o e -i.

L'opzione   -o < nomefile > permette di salvare lo stato della EEPROM

(simulata) della carta su un file.

L'opzione -o < nornefile > permette di usare il file specificato per inizializzare la EEPROM.

Ad esempio, scrivendo cref -o eeprom.txt, durante la simulazione, lo stato della EEPROM verrà salvato nel file eeprom.txt .

Supponiamo che durante questa simulazione venga installata un'applet sulla cart Se avvio una seconda simulazione usando cref -i eeprom.txt, la simulazione riparte con l'applet già installata sulla carta (non ci sarà bisogno di reinstallarla per poterle mandare delle APDU).

6.2 Il comando scriptgen

Una volta creato il CAP file contenente l'applet da installare, prima di installarlo sulla carta (simulata) ed usarlo, deve essere convertito in una sequenza di APDU da inviare al simulatore. Per far questo si deve usare il comando scriptgen.

Lo scriptgen genera un file di testo che contiene le APDU necessarie per l'installazione di un'applet sulla cart Il file risultante deve essere leggermente modificato e per queste modifiche si rimanda alla pagina xx della guida al kit di simulazione [3].

Vediamo sinteticamente come scrivere il comando:

scriptgen [opzioni] -o AppletProvscr

AppletProvcap

Viene generato un file di testo AppletProvscr nella directory specificata

avendo preso in ingresso il file AppletProvcap.

6.3 Il comando apdutool

Dopo aver completato le modifiche dello script, esso può essere passato come parametro al comando apdutool in modo da inviare al simulatore cref le APDU contenute nello script.

Arrivati a questo punto si devono seguire le seguenti procedure per far funzionare la simulazione:

1. Far partire cref in una finestra DOS, specificando eventualmente le opzioni -o e/o  -i.

2. Far partire il comando seguente in un'altra finestra DOS:

C:esempio> apdutool -o <output file>

. . .AppletProvscr

Dopo aver lanciato questo comando si avvia a tutti gli effetti la simulazione e vengono inviate alla carta tutte le APDU presenti nello script.

3. Alla fine della simulazione si può leggere il file specificato in

< outputfile > (che è un file di testo) per vedere i risultati della

simulazione.