Java Card

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

Java Card est un système d'exploitation pour carte à puce qui fournit essentiellement un environnement d'exécution pour un sous ensemble du langage Java spécifiquement destiné aux applications pour Carte à puce. Java Card permet l'exécution d'applications au sein des cartes à puce, qui offrent des capacités de mémoire et de traitement limitées. De multiples applications peuvent être déployées avant et même après que la Carte à puce a été fournie à l'utilisateur final. Les applications écrites dans le langage de programmation Java peuvent être exécutées en toute sécurité sur l’ensemble des types de cartes disponibles sur le marché.

Historique[modifier | modifier le code]

En 1996, les ingénieurs de la division carte de Schlumberger[1] au Texas (qui a fusionné plus tard avec Gemplus international pour former Gemalto ) ont souhaité simplifier la programmation des cartes à puces tout en préservant la sécurité des données dans le respect de la norme ISO 7816.

La solution retenue fut le langage de programmation Java. En raison de la faible capacité mémoire disponible sur une Carte à puce seulement un sous-ensemble de Java pouvait être utilisé. Ainsi fut créé Java Card 1.0 en novembre 1996, le premier langage orienté objet adapté aux cartes à puce.

Février 1997, Schlumberger et Gemplus fondent Java Card Forum qui recommande des spécifications à JavaSoft (la division de Sun à qui appartient Java Card ) en vue d'obtenir une standardisation du langage et promeut les APIs de Java Card pour qu'elle devienne la plate-forme standard de développement des applications pour les cartes à puce[1].

Novembre 1997, les producteurs de Cartes à puce comme De La Rue, Bull , Giesecke & Devrient(G&D) rejoignent Java Card Forum qui édite une nouvelle version de spécifications Java Card 2.0[1].

Par la suite, Sun éditera alors quatre nouvelles spécifications : en mars 1999 édition de Java Card 2.1[1], en juin 2002 Java Card 2.2, en mars 2008 Java Card 3.0 et enfin la plus récente Java Card 3.0.1 en mai 2009[2].

La société Oracle Corporation acquiert en janvier 2010 l'entreprise Sun Microsystems.

Architecture[modifier | modifier le code]

La carte à puce représente une des plates-formes informatiques les plus réduites[3]. Le plus grand défi de conception de la technologie de Java Card est d'embarquer le logiciel de base Java dans une carte à puce en conservant l'espace mémoire nécessaire pour stocker des applications. La solution retenue par Sun, issue des travaux de Schlumberger [1], est d’implémenter un sous-ensemble des fonctionnalités du langage Java et d’appliquer un modèle réduit de la JVM (Java Virtual Machine ) appelé JCVM (Java Card Virtual Machine )[3]. En plus de fournir le support de langage Java, la technologie de Java Card définit un environnement d'exécution en temps réel qui supporte la mémoire, la communication, la sécurité et le modèle d'exécution de l’application. Cet environnement respecte la norme standard ISO7816[4].

présentation architecture

La plate-forme Java Card est articulée autour[5] :

  • d’une machine virtuelle Java Card appelée JCVM[note 1]dont les spécifications définissent les fonctionnalités mises en œuvre par la technologie Java Card. Elles incluent le jeu d'instruction de la Machine Virtuelle Java Card, un sous-ensemble du langage Java et les formats de fichier utilisés pour installer des applets et des bibliothèques dans des cartes à puce ou autres périphériques qui hébergent la technologie de Java Card[6].
  • d’un environnement d’exécution Java Card appelé JCRE[note 2] constitué de composants systèmes. La JCRE est responsable de la gestion des ressources des cartes à puces, des communications réseaux, de l'exécution ainsi que la sécurité des Applets. La JCRE sert de système d'exploitation de la carte à puce, celui-ci s'appuie sur la couche matérielle de carte à puce et du système natif[6].
  • d’un ensemble de librairies accessibles APIs[note 3], un sous ensemble du JCRE, contenant les définitions de classe requises pour supporter la JVCM et la JCRE. Il décrit les fonctions de bases utiles pour programmer des applications de cartes à puce[6].

La caractéristique la plus significative du JCRE est qu'il fournit une séparation claire entre le système et les applications[6]. La technologie de Java Card définit une plate-forme sur laquelle les applications écrites dans le langage de programmation Java peuvent fonctionner sur carte à puce et autres périphériques avec mémoire[6]. Les applications Java Card sont vues comme des applets[6] ou des servlets[7].

À partir de la version 3.0, édité par Sun en mars 2008, suite aux évolutions des cartes à puces, la plate-forme Java Card se décline en 2 versions[8].

Version Classique [9]
Cette version est une évolution de la version 2.2 et cible les systèmes limités en ressources et qui supportent les applications basées sur les Applets. Elle apporte des correctifs et offre l’exploitation de nouveaux algorithmes de sécurité (Exemple support des clés RSA 4096 bits ), ainsi qu'un ajustement avec les récents standards des cartes «sans contact» a été réalisé.
Version Connectée [9] 
Cette version apporte un environnement amélioré d’exécution et une nouvelle machine virtuelle. Une nouvelle architecture a été conçue pour transformer la carte à puce en élément sécurisé de réseau. La carte à puce peut alors fournir des services réseaux IP tels que serveur web HTTP, serveur web sécurisé HTTPS, identification, accès aux ressources d'un réseau. Cette version cible des produits moins limités en ressources incluant de nouvelles fonctionnalités orientées réseau telles que les applications web, appelées servlet. Cette version intègre les fonctionnalités de la version classique.
Schéma de l'architecture


Version Java Card 2.x et Java Card 3 « classique »[modifier | modifier le code]

Java Card est donc l'adaptation de la technologie Java pour les cartes à puce. Les applets sont développées dans le langage Java, elles sont ensuite transformées afin de satisfaire les contraintes de mémoire, puis sont chargées dans la carte[3]. Une fois installé sur la plate-forme et sélectionné, le bytecode[note 4], de l'applet est exécuté par la machine virtuelle embarquée JCVM[10].

Machine Virtuelle Java Card[modifier | modifier le code]

La JCVM exécute le bytecode, contrôle l'attribution de la mémoire, gère les objets et met en application la sécurité pendant l'exécution. La capacité des cartes à puces étant trop limité pour contenir toutes les informations des fichiers de classe Java, vérificateur de code objet, la JVCM est donc implémentée en deux parties distinctes (principale différence entre la JVM et la JCVM )[11] :

Java Card Virtual Machine

Ensemble, ils implémentent le chargement des fichiers de classe Java par l’intermédiaire du vérificateur et convertisseur pour enfin exécuter l'applet à l'aide de l’interpréteur.

le vérificateur[12] 
examine un ou plusieurs fichiers de classe contenant le bytecode, pour assurer qu'il respecte la syntaxe et les règles du langage et vérifie statiquement que les flux de contrôle et de données ne produiront pas d'erreur lors de l’exécution[13].
le convertisseur 
charge les fichiers de classe vérifiés par le vérificateur. Il produit un fichier CAP[note 8], (contenant une représentation compacte d'un ou plusieurs fichiers Java compilés) correspondant à la conversion d’une applet[14].

En plus de la création d'un fichier CAP, le convertisseur produit un fichier d'exportation [note 9] contenant des informations API publiques pour un ou plusieurs fichiers de classe[15]. Il définit le niveau d'accès et le nom d'une classe ainsi que le niveau d'accès et les signatures des méthodes et champs de la classe. Un fichier d'exportation contient aussi des informations utilisées pour résoudre des jonctions de référence entre différentes applets sur la carte[10].

L’interpréteur de Java Card fournit le support d'exécution du langage Java, il exécute les tâches suivantes[16] :

  • exécute des instructions de code des applets ;
  • contrôle la création d'objet et l'attribution de mémoire ;
  • joue un rôle crucial dans l'assurance de la sécurité pendant l'exécution.
gestion transfert fichier(s)

L’interpréteur de Java Card ne charge pas de fichier de classe ou fichier CAP, il en exécute seulement le code[16]. Dans la technologie de Java Card, les mécanismes de téléchargement et d'installation sont inclus dans une unité appelée l'installateur résidant dans la carte à puce[16]. Il coopère avec un programme d'installation non-implémenté sur la carte. Le programme d'installation transmet le(s) fichier(s) à l'installateur sur la carte via un dispositif d'acceptation de carte (CAD[note 10]). L'installateur écrit le(s) fichier(s) dans la mémoire de carte à puce pour être lu avec les autres classes qui sont déjà embarquées sur la carte. Il crée et initialise les structures de données qui sont utilisées par la JCRE.

Environnement d'exécution Java Card[modifier | modifier le code]

Le JCRE est responsable de la gestion des ressources de la carte, des communications réseaux, de l'exécution et la sécurité des applets[17]. Il est implémenté sur la carte à puce et sert essentiellement au système d'exploitation présent sur la carte[17]. Le JCRE est composé de la JCVM, des APIs, d'extensions spécifiques à une industrie[note 11]. et des systèmes de classes [17].

JCRE Architecture

Le JCRE distingue les applets des propriétés techniques de la carte à puce. Il fournit le système standard et les APIs pour les applets. Celles-ci sont donc plus simples à écrire et sont donc facilement portables sur différentes architectures de cartes à puce[17].

La couche inférieure du JCRE contient la JCVM et les méthodes natives [note 12]. Elles fournissent le support à la JCVM et le système de classes pour la couche suivante. Le système de classes cadre le fonctionnement du JCRE[18] et son rôle est similaire à un système d'exploitation. Il est responsable :

de la gestion des transactions 
mécanisme permettant de rendre un ensemble d’opérations atomiques (ex : transaction bancaire )[19].
des communications avec le serveur CAD 
La gestion des communications d'Applets, se fait via l’Application Protocol Data Unit (APDU)s dont la structure est définie par la norme ISO 7816[19].
du cycle de vie des applets 
Le JCRE initialise l'applet après son installation. Il peut sélectionner alors l'applet pour lui signifier de s’exécuter, la dé sélectionner ou lui transmettre un signal APDU[19].

Le système de classes invoque les méthodes natives[20]. Elles contiennent un ensemble de fonctions bas niveau qui permettent au JCRE de gérer les ressources physiques de la carte telles que les entrées-sorties, la gestion de la mémoire ou le coprocesseur cryptographique. Ces méthodes sont compilées en code exécutable dédié au processeur de la carte[17].

La structure de classes API définit les interfaces de programmation d'application, API[18]. L'avantage majeur est qu'elle rend plus facile la création d'applet. Les développeurs d'applet peuvent concentrer leurs efforts sur la programmation vis-à-vis des contraintes de l'infrastructure de système de carte à puce grâce aux extensions d'API disponibles[20]. Les applets ont accès aux services JCRE par des classes API.

La structure extension spécifique à une industrie fournit les bibliothèques complémentaires de services supplémentaires ou des modèles de système et de sécurité (ex : industries financières)[18].

L'installateur permet le téléchargement sécurisé de logiciels et d’applets sur la carte après que la carte a été produite et fournie à l'utilisateur[18]. L'installateur interne coopère avec l'installateur externe à la carte. Ensemble, ils accomplissent la tâche de charger le contenu binaire du fichier CAP ou fichier de(s) classe(s). Cependant, l'installateur est un composant JCRE facultatif, mais sans lui tous logiciels de carte, y compris les applets, devraient être écrits dans la mémoire de la carte pendant le procédé de fabrication[17].

API[modifier | modifier le code]

L’interface de programmation d'application API disponible permet de développer des applications et fournir des services à ces applications[21] : Ces classes définissent les conventions selon lesquelles une Applet Java Card a accès au JCRE et aux fonctions natales, y compris la fonction de système d'exploitation, l'accès à la mémoire et les opérations d'entrée-sortie. Les API utilisées par la carte sont :

java.io 
est un sous-ensemble du paquet java.io dans le langage de programmation Java standard.
Java.lang 
fournit les fondamentaux pour la conception du sous-ensemble de technologie de Java Card du langage de programmation Java. Les classes fournies sont tirées de java.lang dans le langage de programmation Java standard et représentent la fonction principale requise par la JVCM. Cette fonction principale est représentée par la classe d'Objet, qui est la super-classe pour toutes les classes de langage Java et la classe Exception, qui est la super-classe pour l'exception et les classes d'exception pendant l'exécution.
Java.rmi 
définit l'interface à distance qui identifie les interfaces dont les méthodes peuvent être invoquées du périphérique de réception de carte (CAD ) des applications client.
Javacard.framework 
fournit une structure de classes et des interfaces pour la conception et la communication des applets, contient les fonctionnalités essentielles de fonctionnement avec Java Card.
Javacard.framework.service 
fournit une structure de services de classes et d’interfaces qui permettent à une Applet de Java Card d'être conçue comme une liste de composants de services.
Javacard.security 
fournit les classes et les interfaces qui contiennent la fonction disponible pour implémenter une sécurité et une structure de cryptographie sur la Java Card. Les classes du paquet Javacard.security fournissent les définitions des algorithmes qui exécutent cette sécurité et les fonctions de cryptographie[22] :
  1. Mises en œuvre de clés de chiffrement différentes par la classe KeyBuilder ;
  2. Hachage des données par la classe MessageDigest ;
  3. Génération de données aléatoires par la classe RandomData ;
  4. Signature par la classe Signature ;
  5. Echanges de clé de session par la classe KeyAgreement.
Javacardx.crypto 
contient la fonction qui implémente la sécurité et la structure de cryptographie sur la Java Card. C'est une extension du paquet précédent. Il contient la classe Cipher et l'interface KeyEncryption. Cipher est une classe qui fournit des méthodes pour chiffrer et déchiffrer des messages[23]. KeyEncryption est une interface qui fournit la fonction qui permet aux clés d'être mises à jour d'une façon continue sécurisée.

Version Java Card 3 « Connectée »[modifier | modifier le code]

La version 3 « Connectée » des spécifications de la plateforme Java Card présente des différences profonde avec les autres versions existantes.

Tout d'abord, alors que les versions antérieures ne pouvaient charger que des fichiers binaires spécifiques (les fichiers CAP), les applications Java Card 3 « Connectées » sont déployées sous forme de fichiers java compilés de façon conventionnelle (des fichiers .class) regroupés dans des fichiers .jar, à l'instar des machines virtuelles java conventionnelles[24]. Il n'est alors plus nécessaire d'avoir recours à des outils de conversions de code.

Par ailleurs Java Card 3 « Connectée » privilégie le mode de communication de l'internet : les protocoles internet via norme IP ISO 7816-4 pour les interfaces « avec contacts ». La norme ISO 14443 est elle utilisée pour les interfaces «sans contact»[9]. Les applications Java Card 3 « Connectées » sont en fait, des Servlets, c'est-à-dire de véritables Services Web, qui respectent, à ce titre, le protocole HTTP.

La machine virtuelle Java Card 3 est basée sur le CLDC[note 13] largement utilisé dans le monde de la téléphonie mobile[25]. Cette plate-forme donne accès aux fonctionnalités les plus riches du langage JAVA[9]. La plate-forme CLDC a été réduite en taille, les protocoles et les systèmes sécurités de cartes à puce ont été intégrés[9].

Évolution des périphériques supportant la technologie Java Card[26]

Diagramme appel mode connecté (utilisation Http)
Carte à puce traditionnelle Carte à puce récente compatible V3
8/16-bit CPU 32-bit CPU
2 kb RAM 24 kb RAM
48 kb - 64 kb ROM >256 kb ROM
8-32 kb EEPROM >128 kb EEPROM
Serial I/O interface High-speed interfaces
9,6 kb/s - 30 kb/s 1,5 Mb/s - 12 Mb/s
Full duplex Half duplex

Amélioration apportée par la version 3 connectée[24].

  • Applications de type servlets[24].
  • Gestion de multitâches (Multithreading)[24].
  • Vérification par byte code interne [24](Vérification de .class par la machine virtuelle interne).
  • Ramasse Miette automatique (Garbage collector) inclut dans la machine virtuelle[24].
  • Ajout des types Char, Long et String[24].
  • Tableau multidimensionnel[27].
  • Classe représentant les types primitifs (Boolean, Integer,… )[27],[28]
  • Classe de la manipulation de Chaines de caractères (StringBuilder…)[27],[29].
  • Classe pour la gestion des Entrées/Sorties (Reader, Writer et Stream )[27].
  • Classe pour la gestion du réseau[27].
  • Classe pour la gestion des collections (Vector, hashtable…)[27].
  • Classe pour la gestion des dates[27].
  • Classe pour la gestion de la localisation et de l’internationalisation[27].
  • Le langage de programmation a été étoffé de spécificités issues de Java SE[27] :


Spécificités
Générics[30]
Métadonnées
Autoboxing[31]
Amélioration de la boucle for
Assert (test unitaire)
Énumération[32]
Utilisation de méthodes à argument Variables[31]
Import static[33]

Limitation du moteur de servlet de java card V3[34]

Liste des principales caractéristiques présentes dans les spécifications Java Serlet 2.4 [35] qui ne sont pas supportées par la plate-forme Java Card V3.

  • API non supportées (java.io.File, java.net.URL, java.util.Map, java.util.Set, java.security.cert.X509Certificate...). Par exemple, il est impossible d'effacer un fichier avec la méthode delete de la classe java.io.File, impossible d’utiliser la structure hashmap, impossible d'utiliser la gestion des certificats X509 (RFC 2459 ).
  • Nombre flottant (float). Il est impossible de réaliser des opérations sur des nombres à virgules.
  • Sérialisation et clonage d'objets (java.io.Serializable, java.lang.Cloneable ). Il impossible de convertir les objets en flux binaire pour gérer persistance. Il est impossible de créer de nouvelles instances à partir d'une référence d'objet (clone).
  • Support des Java Server Pages V2.0. Les balises JSP ne sont pas reconnues, donc obligation d'écrire des servlets en Java.
  • Java Naming and Directory Interface. Pas d’accès aux classes de gestion d'annuaires.

Sécurité des applications Java Card[modifier | modifier le code]

La gestion de la sécurité développée pour les cartes à puce est implémentée par la JCVM qui fournit les règles de sécurité suivantes[36] :

  • Chaque JCVM contient une fonction vérificateur dont le rôle est de vérifier les fichiers Java compilés (.class ) issue d'un compilateur java. Cependant sur la plate-forme Java Card version 3, il est possible de charger directement des fichiers de classes sans passer par le vérificateur et le convertisseur.
  • La fonction sécurité de la JCRE met en application des pare-feu pour isoler chaque applet ou servlet, ce qui empêche l'accès non autorisé d'objets créés par une autre applet.
  • Tous les accès aux méthodes et variables dans un fichier de classe se font par accesseurs[note 14]. Ces accesseurs définissent un contrôle de cohérence du type primitif pour chaque méthode. Il est possible de déclarer une méthode « public », « protected » (accessibles par des méthodes dans la même sous-classe ou « package ») ou « private » (aucun accès par d'autres classes ). Si aucune déclaration n'est faite, la méthode peut être accessible par n'importe quelle classe dans le même paquet.

Au-delà de la vérification de code objet implémentée par la JCVM, la plate-forme de Java Card 3 implémente des mécanismes de sécurité qui fournissent le niveau d'application et la sécurité des communications[37].

La plate-forme de Java Card supporte un mécanisme d'isolement de code. L'isolement de code assure que le code chargé d'une application ne se heurte pas au code d'autres applications[38].

La plate-forme de Java Card supporte l'isolement de contexte[note 15] et d’applications. L'isolement de contexte assure que les objets créés, donc en possession d’applications fonctionnant dans un même contexte, ne peuvent pas être accédés par des applications d'un autre contexte à moins que ces applications possédant ces objets ne fournissent explicitement des interfaces pour l'accès. De telles interfaces sont appelées des interfaces en commun et des objets implémentant ces interfaces, appelés commun interface objets, constituent des points d'entrée légaux à ces applications[38].

La sécurité à base de rôles permet à la politique de sécurité d'une application de limiter l'accès aux ressources protégées de l’application. Les restrictions sont basées sur les caractéristiques de l'application demandant l'accès, comme son identité et l'identité de l'utilisateur sur lequel la défense d’accès est demandée[38].

L'authentification de l'utilisateur est le processus par lequel un utilisateur prouve son identité à la carte. Cette identité authentifiée est alors utilisée par la plate-forme pour exécuter des décisions d'autorisation, comme celles requises par la sécurité à base de rôles, pour avoir accès aux ressources protégées[39].

L'authentification d'application client est le processus par lequel une application cliente prouve son identité à une application serveuse. Cette identité authentifiée est alors utilisée par l'application serveuse pour exécuter des décisions d'autorisation dans le but d'avoir accès aux ressources protégées[39].

Avec la plate-forme java Card, les applications peuvent interagir avec des applications à distance par des communications de réseaux sécurisées (TLS, SSL )[40].

Un développeur d'application Web peut déclarer des pré-requis pour l'intégrité et la confidentialité lors du déploiement d'une application Web. Le développeur d'application ou le fournisseur peut aussi exiger que l'on héberge l'application sur un port sécurisé dédié avec des connexions HTTPS ouvertes[40].

La plate-forme Java Card supporte une structure de cryptographie. Un développeur d'application ou un fournisseur peut choisir l'algorithme de cryptographie qui répond le mieux aux besoins de son application [41].

Concept de programmation[modifier | modifier le code]

Principe de programmation d'une Applet[modifier | modifier le code]

Un Applet Java Card respecte la norme ISO 7816. C’est-à-dire qu’elle répond à des requêtes de la même manière qu’elle les reçoit sous la forme de commandes en byte codes. Ceci simplifie considérablement le développement d’une application, car il n’y a plus besoin de coder en bas niveau l’envoi et la réception des commandes. En effet cette partie est maintenant encapsulée dans un framework java.

Les commandes en byte code sont appelées des APDU (Application Protocol Data Unit). Celles-ci sont codées différemment en fonction de l’envoi et de la réception[42].

Une commande APDU telle qu'elle est envoyée depuis le lecteur à la carte Java est une série de cinq octets éventuellement suivis d'un nombre variable d'octets, formatés comme suit :

Format d'une commande APDU.
CLA 
CLA est le nom du premier octet, dit octet de classe, défini par la norme ISO 7816, indiquant le numéro de commande[42].
INS 
INS est le nom du second octet, dit octet d’instruction[42].
P1 
P1 est le nom du troisième octet, dit octet de paramètre 1[42].
P2 
P2 est le nom du quatrième octet, dit octet de paramètre 2[42].
Ln 
Ln est le nom du cinquième octet, il indique le nombre d'octets de données qui vont suivre (qu'elles soient envoyées ou reçues, 0x00 indiquant qu'aucune donnée additionnelle ne suivra)[42].
Données 
Ce sont les données, au nombre de Ln, qui sont transmises par le lecteur à la carte. Si l'application embarquée prévoit seulement une transmission en sens inverse, aucune donnée n'est transmise ici[42].
Le 
Le est le dernier octet après les données indiquant la taille maximale des données pour la réponse[42].


Une réponse APDU telle qu'elle est envoyée depuis la carte Java au lecteur, est une série d'octets, retournée en réponse à une commande et formatée comme suit :

Format d'une réponse APDU.
Données 
Ce sont les données, au nombre de Ln, qui sont envoyées par la carte au lecteur[42].
Statut 
statut renvoyé par la carte, codé sur deux octets nommés : SW1 et SW2.
SW1 
le premier octet, appelé SW1 indique le type de réponse. La valeur hexadécimale une valeur entre 0x90 et 0x9F indique que la commande a été correctement exécutée. Une valeur entre 0x60 et 0x6F indique que la commande n'a pas pu être exécutée par le programme placé dans la carte[42].
SW2 
le second octet, appelé SW2 rapporte éventuellement des informations supplémentaires concernant la réponse[42].

Lorsque la commande au niveau de l’applet s’exécute normalement, la valeur du statut renvoyé correspond à 90 00.

Si une instruction INS prévoit à la fois d'envoyer et de recevoir des données, Java Card normalise un système d'APDU en deux phases. Dans un premier temps, l'APDU est envoyée avec pour <Ln> un nombre d'octets à envoyer, puis lorsque la carte répond 0x91 <Le> (indiquant que <Le> octets sont prêts à être retournés par la carte, en réponse à la commande ) une APDU Get Response est transmise pour déclencher la réception de ces <Le> octets sortants[42].

En résumé, le champ de donnée(s) est optionnel dans les deux cas, APDU de commande et APDU de réponse. Par conséquent, il y a quatre cas possibles de communication entre le client et la plateforme Java Card™ Platform, Version 3.0.1 Connected Edition :

Cas 1 APDU de commande sans donnée APDU de réponse sans donnée
Cas 2 APDU de commande avec donnée(s) APDU de réponse sans donnée
Cas 3 APDU de commande sans donnée APDU de réponse avec donnée(s)
Cas 4 APDU de commande avec donnée(s) APDU de réponse avec donnée(s)
Format de l'identifiant d'application.

Avant de pouvoir transmettre une commande à une Applet déployée dans une Java Card, il est nécessaire de la sélectionner par l’envoi d’une commande APDU spécifique en précisant l’identifiant de l’application AID [note 16]. L’identifiant d’application est composé de deux parties. La première sur 5 octets, le RID [note 17], est assigné par la norme ISO. Celui-ci correspond à l’identifiant propre à l’entreprise. Le second, PIX [note 18] est quant à lui composé entre 0 et 11 octets. L’assignation de celui-ci reste à la charge de l’entreprise qui développe l'application Java Card[43].

Pour la programmation d’une Java Card, il y a cinq étapes importantes :

  • Écriture du code Java source ;
  • Compilation du code ;
  • Conversion des fichiers .class en .cap ;
  • Vérification du fichier .cap (optionnel ) ;
  • Installation du fichier .cap dans la Java Card.

Le point fort du développement Java Card est que les deux premières étapes peuvent être réalisées avec un environnement de développement JAVA classique.

Voici un exemple de code renvoyant tout simplement la chaine de caractères ‘Hello World’ sur la demande liée à l’instruction 0x10. Dans cet exemple le AID est composé des valeurs de RID = DA8EF6DD26 et de PIX = 86E899.


Exemple d’applet ‘Hello World’[44].

import javacard.framework.*;
 
public class HelloWorld extends Applet {
 
    // Initialisation de la variable avec ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ' ', 'W', 'o', 'r', 'l', 'd'.    
    private final static byte[] message = { 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64 };
 
    public static void install(byte[] bArray, short bOffset, byte bLength) { new HelloWorld(); }
 
    protected HelloWorld() { register(); }
 
    public void process(APDU apdu) {
        if (selectingApplet()) {
            // Retourne le status à OK
            return;
        }
        byte[] buffer = apdu.getBuffer() ;
        if ( buffer[ISO7816.OFFSET_CLA] != (byte)(0x80) )
            ISOException.throwIt(ISO7816.SW_CLA_NOT_SUPPORTED);  // Retourne le status word CLA NOT SUPPORTED
            switch(buffer[ISO7816.OFFSET_INS]) {
                case 0x10 :
                    // Copie du contenu du message dans le buffer de la reponse 
                    Util.arrayCopy(message, (byte)0, buffer, ISO7816.OFFSET_CDATA, (byte)message.length);
                    // Envoi de la réponse
                    apdu.setOutgoingAndSend(ISO7816.OFFSET_CDATA, (byte)message.length);
                    break;
                default:
                    // Retourne le status à la valeur INS NOT SUPPORTED
                    ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);                    
             }
    }
}
Diagramme d'appel de l'exemple


Pour cet exemple, deux échanges d'APDU sont nécessaires entre le client et la Java Card : Le premier envoi correspond à la sélection de l'application en précisant l'AID :

Commande : 0x00 0xA4 0x04 0x00 0X08 0XDA 0X8E 0XF6 0XDD 0X26 0X86 0XE8 0X9A

Réponse : 90 00

Le second appel, envoi le code instruction 0x10 correspondant à la fonction 'char* hello()' sans données supplémentaires

Commande : 80 10 00 00 00

Réponse : 48 65 6C 6C 6F 20 77 6F 72 6C 64 90 00

Le contenue de l'APDU de réponse contient les données envoyées par l'Applet suivies du code de retour qui a pour valeur 90 00. Celle ci nous indique que la fonction a été exécutée sans problème. Les données sont composées d'une série d'octets contenant les 11 caractères de la chaîne de caractères 'Hello World'.

Principe de programmation d'une Servlet[modifier | modifier le code]

Voici un exemple de code renvoyant la chaine de caractères ‘Hello World from Java Card’ lors de l'appel à la Servlet.

Exemple de Servlet ‘Hello World’

Contenu du fichier .java

package org.carte.web;
 
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class HelloWorldWeb extends HttpServlet {
 
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        try {
            out.println("<html><head><title>HelloWorldWeb</title></head>");
            out.println("<body><h1>HelloWorldWeb</h1>");
            out.println("Hello World from Java Card</body></html>");
        } finally {
            out.close();
        }
    }
}


Contenu du fichier web.xml

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         version="2.4"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/javacard/jcweb-app_3_0.xsd">
    <description>The web application deployment descriptor conveys web application model
elements and configuration information of an application between application
developers, application assemblers, and deployers.
    </description>
    <display-name>Hello World Web</display-name>
    <servlet>
        <servlet-name>HelloWorldWeb</servlet-name>
        <servlet-class>org.carte.web.HelloWorldWeb</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloWorldWeb</servlet-name>
        <url-pattern>/helloworldweb</url-pattern>
    </servlet-mapping>
</web-app>

L'appel de la Servlet se fait par l’intermédiaire d'un navigateur web en précisant l'URL suivante :

http://adresse_de_la_carte/helloworldweb

L'utilisation des Servlets sur une Java card se fait exactement de la même manière que sur une plate-forme JAVA EE.

Intérêts[modifier | modifier le code]

Les producteurs de cartes à puces (tel que Gemalto, Oberthur Technologies...) implémentent les fonctionnalités de Java Card suivantes[45] :

  • Interopérabilité : les Applets développées avec la technologie Java Card fonctionnent sur n'importe quel type de cartes à puce (et indépendamment du matériel sous-jacent).
  • Sécurité : la technologie de Java Card repose sur la sécurité du langage de programmation Java pour fournir un environnement d'exécution sécurisé.
  • Possibilité d'applications multiples [note 19] : la technologie de Java Card permet à de multiples applications de cohabiter en sécurité sur une seule carte à puce.
  • Dynamique : de nouvelles applications peuvent être installées en toute sécurité après qu'une carte a été fournie à l'utilisateur, permettant aux producteurs de carte de répondre dynamiquement aux besoins de changement de leur client.
  • Compatible avec les normes existantes : l'API de Carte Java est compatible avec les standards internationaux pour Carte à puce comme ISO7816 ou Europay Mastercard Visa :


L'utilisation du langage de programmation Java apporte un gain pour les développeurs d'applications[45] :

  • La programmation orientée objet apporte une plus grande modularité du code et sa réutilisation, augmentant la productivité du programmeur.
  • La protection figurant dans les caractéristiques du langage de programmation Java s'applique aux applets de Java Card, mettant en application des attributs de protection et de typage fort.

Marché[modifier | modifier le code]

De nombreux types de cartes à puce peuvent profiter de la technologie de Java Card[46]:

  • Carte SIM (Subcriber Identity Module) utilisée dans les téléphones cellulaire sur les réseaux sans fil.
  • Carte bancaire.
  • Carte d'identité.
  • Carte santé.
  • Les cartes qui fournissent l'accès logique et physique aux ressources d'entreprises.

Sur la majorité de réseaux téléphoniques cellulaires, un abonné utilise une carte à puce généralement appelée une carte SIM pour activer le téléphone. La carte authentifie l'utilisateur et fournit des clés de chiffrement pour le transport de la voix numérique. les cartes SIM implémentées de la technologie de Java Card peuvent aussi fournir des services transactionnels bancaires à distance. Des centaines de millions de cartes SIM basées sur la technologie de Java Card fonctionnent déjà avec des services innovants sur les téléphones cellulaires.

Dans le secteur bancaire, les cartes à puce donnent l'accès sécurisé aux utilisateurs à une large gamme de services financiers incluant les distributeurs automatiques de billets, le paiement de factures et de péages. La technologie de Java Card permet à une seule carte à puce d'héberger de multiples applications financières et de livrer des services tiers ou de sécuriser sur le commerce en ligne.

De nombreuses applications sont disponibles dans les domaines où la sécurité et l'authentification sont importantes tel que l'accès sécurisé à des installations, dossiers médicaux.

La technologie de Java Card améliore l'accès grand public aux nouveaux services d'e-commerce par l’intermédiaire d'appareils connectés. En effet, les téléphones cellulaires et les équipements de télévision pour chaînes payantes sont les exemples de marchés où la majorité de produits, déjà disponibles, incluent déjà des lecteurs de carte à puce.

Acteurs du marché[47].

Fabriquant Gamme de Produits
STMicroelectronics, Atmel, Infineon, Samsung, NXP, Inside Contactless Semi-Conducteur et Micro-Processeur
Gemalto, Oberthur, Sagem Orga, Giesecke & Devrient Cartes
Ingenico, Verifone, Hypercom, Nokia Terminaux et lecteurs
Orange, RATP, Véolia, BNP Parisbas Opérateur de services et e-Gouvernement
Trusted Logic, Prism, Multos Logiciel embarqués OS et Applications
Cesti, Fime Évaluation et Test
Experian, Atos Worldline, First Data, Sopra Intégration et systèmes

Chiffres

Selon le rapport gouvernemental «Dimension économique et industrielle des cartes à puces» de novembre 2009. Le marché mondiale des cartes à puces a dépasser les 5 milliards d'unités. (Source Nodal)[48].

Glossaire[modifier | modifier le code]

  • AID (Application IDentifier) : une chaine de caractère utilisé comme identifiant unique des Applets de la carte à puce selon la norme

ISO 7816

  • APDU : Abréviation pour Application Protocol Data Units défini selon la norme ISO 7816-4.
  • APPLET : un composant simple d'une application Java Card qui s'exécute dans l’environnement APDU.
  • APPLET ETENDU: Dans le contexte Java Card, Une Applet étendu possède les fonctionnalités de la version connectée. (Exemple : Manipulation de Chaine de caractère).
  • Conteneur d'Applet : Mécanisme qui manage le cycle de vie des Applets. Dans le contexte Java Card, le conteneur fournit les services de communication sur lesquels les commandes d'APDU et des réponses sont envoyés.
  • Ramasse Miette automatique (Garbage collector) : Mécanisme qui libère automatiquement la mémoire utilisé par des objets qui ne sont plus utilisés par l'application. (Uniquement disponible dans la version 3 connectée).
  • SERVLET : Un composant générant dynamiquement du contenu web s’exécutant au sein d'une application web.

Notes et références[modifier | modifier le code]

Notes[modifier | modifier le code]

  1. qui est nommée dans la littérature scientifique anglo-saxonne Java Card Virtual Machine
  2. qui est nommé dans la littérature scientifique anglo-saxonne Java Card Runtime Environment
  3. qui sont nommées dans la littérature scientifique anglo-saxonne Application Programmer Interface
  4. bytecode ou code binaire intermédiaire en Français inclus dans les fichiers de classe (extension .class ).
  5. qui est nommé dans la littérature scientifique anglo-saxonne Off-Card
  6. qui est nommé dans la littérature scientifique anglo-saxonne Private Computer, «Ordinateur personnel» en français.
  7. qui est nommé dans la littérature scientifique anglo-saxonne On-Card
  8. qui est nommé dans la littérature scientifique anglo-saxonne CAP file (Converted APplet )
  9. qui est nommé dans la littérature scientifique anglo-saxonne Export File
  10. qui est nommé dans la littérature scientifique anglo-saxonne Card Acceptance Device
  11. qui est nommée dans la littérature scientifique anglo-saxonne industry-specific extensions
  12. méthodes de bases qui sont nommées dans la littérature scientifique anglo-saxonne natives method
  13. qui est nommée dans la littérature scientifique anglo-saxonne Connected Limited Device Configuration
  14. . Un accesseur est une méthode permettant de récupérer le contenu d'une donnée membre protégée
  15. contexte : Un service de nom associe des noms avec des objets. Une association entre un nom et un objet est appelée une attache et des jeux d'attaches sont appelés un contexte. Un nom dans un contexte peut devoir nécessairement un autre contexte qui utilise les mêmes conventions de nommage ; le contexte attaché est appelé un sous-contexte.
  16. Application IDentifiant Identifiant d'application en Français
  17. Ressource IDentifier Identifiant de la ressource en Français
  18. Proprietary IDentifier extension extension de l'identifiant propriétaire en Français
  19. qui est nommé dans la littérature scientifique anglo-saxonne Application multi capability.

Références[modifier | modifier le code]

  1. a, b, c, d et e Baentsch 1999, p. 37
  2. Oracle : Spécifications des versions
  3. a, b et c Zhiqun 2000, p. 29
  4. ISO7816
  5. Oracle : Chapitre Composants
  6. a, b, c, d, e et f Zhiqun 2000, p. 30
  7. Sun 2008, p. 7
  8. Sun 2008, p. 1
  9. a, b, c, d et e Sun 2008, p. 2
  10. a et b Zhiqun 2000, p. 34
  11. a, b et c Zhiqun 2000, p. 31
  12. Oracle 2002, p. 1
  13. Casset 2002, p. 209
  14. Zhiqun 2000, p. 32
  15. Zhiqun 2000, p. 33
  16. a, b et c Zhiqun 2000, p. 35
  17. a, b, c, d, e et f Zhiqun 2000, p. 36
  18. a, b, c et d Zhiqun 2000, p. 37
  19. a, b et c Dufay,2003, p.28
  20. a et b Zhiqun 2000, p. 38
  21. Gemalto : Chapitre APIs
  22. Sun 2002, p. 147
  23. Ghindici 2006, p. 6
  24. a, b, c, d, e, f et g Sun 2008, p. 5
  25. Sun CLDC : Introduction
  26. Sun 2008, p. 4
  27. a, b, c, d, e, f, g, h et i Sun 2008, p. 6
  28. Type utilisé dans la programmation Java
  29. Classe StringBuilder
  30. Types Générique du language Java
  31. a et b Autoboxing en Java
  32. Énumération du language Java
  33. Import statique du language Java
  34. Java Servlet Specification : Java Card Platform, Version 3.0.1 Connected Edition, p. 3-1
  35. Java Servlet V2.4
  36. Gemalto : Chapitre sécurité
  37. Sun 2008, p. 13
  38. a, b et c Sun 2008, p. 14
  39. a et b Sun 2008, p. 16
  40. a et b Sun 2008, p. 17
  41. Sun 2008, p. 19
  42. a, b, c, d, e, f, g, h, i, j, k et l ISO : norme ISO7816-4
  43. ISO : norme ISO7816-5
  44. Gemalto 2009, p. 19
  45. a et b Oracle : Chapitre bénéfices
  46. Oracle : Chapitre Industries
  47. Dimension économique et industrielle des cartes à puces, p. 29
  48. Dimension économique et industrielle des cartes à puces, p. 19

Bibliographie[modifier | modifier le code]

  • (en) Zhiqun Chen, Java Card Technology for Smart Cards : Architecture and Programmer's Guide, Addison Wesley,‎ 18 septembre 2000 (lire en ligne)
  • (en) M. Baentsch, P. Buhler, T. Eirich, F. Horing et M. Oestreiche, « JavaCard-from hype to reality », IEEE Concurrency, vol. 7, no 4,‎ octobre-décembre 1999, p. 36-43 (ISSN 1092-3063, lien DOI?)
    Secure Syst. Group, IBM Res. Div. Zurich
  • (en) L. Casset et JL. Lanet, « Increasing smart card dependability », ACM,‎ 2002, p. 209 - 212 (lien DOI?)
    EW 10 Proceedings of the 10th workshop on ACM SIGOPS European workshop
  • (en) P.H. Hartel et L. Moreau, « Formalizing the safety of Java, the Java virtual machine, and Java card », ACM Computing Surveys (CSUR), vol. 33, no 4,‎ 2001, p. 517-558 (ISSN 0360-0300, lien DOI?)
  • (en) Dorina Ghindici, Gilles Grimaud et Isabelle Simplot-Ryl, « Embedding verifiable information flow analysis », ACM Computing Surveys (CSUR),‎ 2006, p. 1-9 (ISBN 1-59593-604-1, lien DOI?)
  • Guillaume Dufay, Vérification formelle de la plate-forme Java Card,‎ 2003 (lire en ligne)
  • (en) Java Card™ 2.2 Application Programming Interface : Revision 1.1 for the 2.2_01 Release, 901 San Antonio Road Palo Alto, CA 94303 USA, Sun Microsystems, Inc,‎ 2002, 2.2_01 éd., 278 p. (lire en ligne)
  • (en) THE JAVA CARD™ 3 PLATFORM, 901 San Antonio Road Palo Alto, CA 94303 USA, Sun Microsystems, Inc,‎ 2008, 34 p. (lire en ligne)
  • (en) Gemalto, Java Card™ & STK Applet Development Guidelines : version 2,‎ 2009, WG.GGS.4.0042 éd., 53 p. (lire en ligne)
  • (en) Oracle, Java Card 2.2 Off-Card Verifier : version 2.2, 901 San Antonio Road Palo Alto, CA 94303 USA,‎ 2002, 24 p. (lire en ligne)
  • (en) Java™ Servlet Specification : Java Card™ Platform, Version 3.0.1 Connected Edition, 901 San Antonio Road Palo Alto, CA 94303 USA, Sun Microsystems, Inc,‎ 2009, 162 p.
  • (en) ISO7816-4 Cartes d'identification -- Cartes à circuit intégré : Partie 4 : Organisation, sécurité et commandes pour les échanges,‎ 2005, 2e éd.
  • Dimension économique et industrielle des cartes à puces, www.industrie.gouv.fr,‎ 2009, 1e éd. (lire en ligne), p. 74

Voir aussi[modifier | modifier le code]

Liens externes[modifier | modifier le code]