introjavacard

Introduction à la programmation
de Javacard sous Windows
Par Juju_41
Date de publication : 30 avril 2008
Dernière mise à jour : 30 avril 2008
Tutoriel permettant d'installer et de se familiariser avec un environnement de
développement sous Windows pour la programmation de Javacard ♪

Introduction à la programmation de Javacard sous Windows par Juju_41
I - Introduction..............................................................................................................................................................3
II - But de ce tutoriel................................................................................................................................................... 3
III - Fonctionnement d'une Javacard...........................................................................................................................3
III-A - Quelques spécifications............................................................................................................................... 3
III-B - Les « APDU » : Application Protocol Data Unit........................................................................................... 3
III-C - Identification des applets............................................................................................................................. 4
III-D - Limitations de la machine virtuelle Javacard 2.x.........................................................................................4
IV - Environnement de développement utilisé dans ce tutoriel...................................................................................5
IV-A - Téléchargements......................................................................................................................................... 5
IV-B - Instructions d'installation..............................................................................................................................5
V - Codage d'une applet Javacard..............................................................................................................................6
V-A - Création de l'applet sous Eclipse.................................................................................................................6
V-B - Les méthodes et classes clés de l'applet.................................................................................................. 10
V-C - Codage de notre applet............................................................................................................................. 10
VI - Outils de simulation............................................................................................................................................ 11
VI-A - APDUTOOL : Envoi/Réception d'APDU.................................................................................................... 12
VI-B - JCWDE : Simulateur sans conservation d'état..........................................................................................12
VI-C - CREF : Simulateur avec conservation d'état............................................................................................ 14
VII - Codage d'une application cliente...................................................................................................................... 15
VII-A - Création du projet sous Eclipse............................................................................................................... 15
VII-B - Ajout de la librairie « APDUIO » dans le Classpath.................................................................................17
VII-C - Création de la classe principale...............................................................................................................19
VII-D - Code pour se connecter à la Javacard....................................................................................................20
VII-E - Code pour se déconnecter de la Javacard..............................................................................................20
VII-F - Code pour sélectionner l'applet Javacard................................................................................................ 21
VII-G - Code de la boucle principale de l'application.......................................................................................... 21
VIII - Utilisation de l'application cliente et d'un simulateur........................................................................................ 22
VIII-A - Avec JCWDE........................................................................................................................................... 22
VIII-B - Avec CREF.............................................................................................................................................. 23
IX - Contenu de l'archive livrée avec ce tutoriel....................................................................................................... 24
X - Remerciements.................................................................................................................................................... 24
- 2 -
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à
l'obtention préalable de l'autorisation de l'auteur.
https://julienb.developpez.com/tutoriels/java/introjavacard/

Introduction à la programmation de Javacard sous Windows par Juju_41
I - Introduction
Les Javacard sont apparues sur le marché des cartes à puce aux alentours de 1996. Elles présentent l'avantage de
pouvoir développer des applications utilisant un langage simple, ouvert et compréhensible par un grand nombre de
développeurs. Elles peuvent se présenter sous la forme de carte SIM, carte bancaire, cartes d'accès, etc.
Il se vend pas loin d'un milliard de cartes SIM Java par an dans le monde. En 2006, plus d'un milliard de cartes SIM
Java étaient en circulation dans le monde et plus de 1,5 milliard de cartes à puce Javacard.
Cette technologie, compatible avec les standards Smart Card existants, permet de faire tourner des applications
Java appelées « applets » sur des cartes à puce ayant peu de mémoire (quelques dizaines de Ko). Plusieurs applets
peuvent coexister sur une même Javacard. L'application Monéo, par exemple, est une application qui coexiste avec
l'application Europay Mastercard Visa (EMV) sur une carte bancaire.
II - But de ce tutoriel
L'idée de ce tutoriel est venue au cours de la réalisation d'un projet de développement sur Javacard à l'École Nationale
Supérieure des Télécommunications de Paris. En effet, la recherche d'outils/documents permettant de disposer
d'un environnement de développement fonctionnel fut relativement longue étant donné le manque de ressources
francophones synthétiques. Le présent document est donc destiné à vous éviter de perdre trop de temps sur certains
détails pratiques …
Vous pourrez ainsi vous familiariser avec les Javacard dans un environnement de développement gratuit permettant
de développer des applets, développer des applications clientes et de les tester à l'aide d'un simulateur de carte.
Nous n'irons pas plus loin que la simulation dans ce tutoriel, car la procédure de transfert
sur carte réelle dépend en grande partie de l'environnement logiciel fourni par le fabricant du
lecteur de carte.
III - Fonctionnement d'une Javacard
III-A - Quelques spécifications
Les Javacard respectent le standard ISO7816 introduit en 1988. Ce dernier décrit (entre autres) l'interface de
communication entre la carte et le terminal. Le lecteur fournit la tension d'alimentation et l'horloge de fréquence 3,5
MHz. L'échange de données est assuré par une liaison série half-duplex de débit compris entre 9600 et 115200 bauds.
III-B - Les « APDU » : Application Protocol Data Unit
Les échanges entre carte et terminal se font au moyen d'APDUs (suite d'octets respectant le format défini dans le
standard ISO7816-4).
Nous utiliserons dans ce tutoriel l'APDU de requête suivante :
Offset 1 2 3 4 5 6 … 6 + (Lc
- 1)
6 + Lc
DonnéesCLA INS P1 P2 Lc Données (si Lc > 0) Le
• CLA = octet de classe défini par l'ISO 7816 fournissant un certain nombre d'informations sur la commande
(exemples : 0xBC pour les cartes vitales, 0x0A pour les cartes SIM, 0x00 pour les Mastercard/Visa)
- 3 -
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à
l'obtention préalable de l'autorisation de l'auteur.
https://julienb.developpez.com/tutoriels/java/introjavacard/

Introduction à la programmation de Javacard sous Windows par Juju_41
• INS = octet d'instruction
• P1 = paramètre 1
• P2 = paramètre 2
• Lc = taille des données (0x00 si pas de données)
• Le = taille maximale des données pour la réponse
La carte répond en envoyant les données de réponse (s’il y a) suivies d'un status word codé sur 2 octets (nommés
SW1 et SW2). Généralement, SW1 indique le type de réponse et SW2 fournit des informations supplémentaires.
Quelques exemples de status word :
SW1 SW2 Signification
0x90 0x00 Pas d'erreur
0x61 xx Pas de problèmes
0x62 ou 0x63 xx Avertissement
0x64 xx Erreur d'exécution
0x67 xx Commande incorrecte
III-C - Identification des applets
Les applets sont identifiées par un AID (Applet ID) composé de 5 à 16 octets. Les 5 premiers correspondent à l'ID
du fournisseur d'application (RID) et les suivants identifient l'application. Les RID sont fournis par l'ISO et il existe
des RID réservés au développement.
Afin de pouvoir communiquer avec elle, une applet doit être préalablement sélectionnée à l'aide de l'APDU suivante
via la commande SELECT (AID sur 16 octets dans cet exemple) :
CLA INS P1 P2 Lc Données
0x00 0xA4 0x04 0x00 0x10 AID sur 16
octets
III-D - Limitations de la machine virtuelle Javacard 2.x
Le framework Javacard 2.x est un sous-ensemble du langage Java. Il ne supporte que les éléments suivants :
• types primitifs boolean, byte et short ;
• les tableaux à une dimension ;
• les packages, classes, interfaces, exceptions ;
• l'héritage, les objets virtuels, la surcharge ;
• la création d'objets (new) mais uniquement dans son constructeur/sa méthode d'installation (donc pas de
création d'objets en runtime).
Ainsi les types long, double, float, char, l'objet String et les tableaux à plusieurs dimensions ne sont pas autorisés.
La création d'objet (new) en runtime est techniquement possible, mais vivement déconseillée
étant donné que les Javacard n'embarquent pas de garbage collector. De plus, la mémoire
embarquée étant très faible, on n’a aucune garantie qu'il y aura assez de mémoire en runtime
pour créer une nouvelle instance de classe.
- 4 -
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à
l'obtention préalable de l'autorisation de l'auteur.
https://julienb.developpez.com/tutoriels/java/introjavacard/

Introduction à la programmation de Javacard sous Windows par Juju_41
IV - Environnement de développement utilisé dans ce tutoriel
Afin de pouvoir développer une applet Javacard et une application cliente, nous allons installer un environnement de
développement. Les outils utilisés dans ce tutoriel sont :
• le Java Card Development Kit 2.2.2 ;
• l'environnement de développement Eclipse version 3.2.2 ;
• le plugin d'intégration Eclipse-JCDE version 0.1.
Ces outils requièrent Java version 1.5 ou supérieur.
IV-A - Téléchargements
• Java Card Development Kit 2.2.2 : archive java_card_kit-2_2_2-windows.zip (lien)
• Eclipse 3.2.2 : archive eclipse-SDK-3.2.2-win32.zip (lien)
• Eclipse-JCDE 0.1 : archive eclipse-jcde-0.1.zip (lien)
IV-B - Instructions d'installation
Tout d'abord, dézipper l'archive java_card_kit-2_2_2-windows.zip dans le dossier de votre choix (C:\JCDK dans
ce tutoriel). Dézipper ensuite les 4 archives du dossier C:\JCDK\java_card_kit-2_2_2 dans ce même dossier. De
cette manière vous devriez voir apparaître (entre autres) les dossiers suivants :
•C:\JCDK\java_card_kit-2_2_2\bin : contient les outils du JCDK (simulateur…) ;
•C:\JCDK\java_card_kit-2_2_2\lib : contient les librairies du JCDK ;
•C:\JCDK\java_card_kit-2_2_2\jc_specifications\specs\api\html : contient l'API du JCDK (très utile).
Afin de pouvoir utiliser les outils du JCDK en ligne de commande, il faut définir 2 variables d'environnement :
JAVA_HOME contenant le chemin d'accès à Java et JC_HOME contenant le chemin d'accès au JCDK. Il peut alors
être utile de créer un script batch permettant d'initialiser ces variables et actualiser la variable PATH. Pour ce tutoriel,
nous créons le script setvars.bat suivant :
@echo off
set JAVA_HOME=c:\java
set JC_HOME=c:\JCDK\java_c~1
set PATH=%PATH%;%JC_HOME%\bin
Installer ensuite Eclipse : dézipper l'archive eclipse-SDK-3.2.2-win32.zip dans le dossier de votre choix (C:\Program
Files\Eclipse dans ce tutoriel).
Installer le plugin EclipseJCDE : placer le contenu du dossier plugins de l'archive eclipse-jcde-0.1.zip dans le dossier
plugins d'Eclipse (C:\Program Files\Eclipse\plugins dans ce tutoriel).
À ce stade, nous disposons d'un environnement de développement permettant de créer des Applet Javacard, de les
simuler et créer des applications clientes.
- 5 -
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à
l'obtention préalable de l'autorisation de l'auteur.
https://julienb.developpez.com/tutoriels/java/introjavacard/