API vs. APDU

Before Java Card, a smart card specification consisted in the definition of a set of APDU commands, with a precise syntax, and in most cases, a precise semantics associated to that syntax. With Java Card, for the first time, an API was designed to run inside the card.

At that time, some of us believed that this would lead rapidly to a paradigm shift in the card world, with the definition of card products shifting from the definition of APDUs (which are low-level communication protocol items) to a more noble definition of API, closer to a functional definition. That’s why we worked on the definition of the Java Card RMI protocol, whose objective was to allow the definition of interfaces to communicate with cards independently of protocols.

Well, we were wrong. Maybe not on the principles, but most definitely in practice. Nobody adopted the RMI protocol, and APDU protocols are still being defined today. In the world of smart cards, this makes sense, since low-level considerations remain a significant challenge (for instance, performance issues in some contactless transactions). In payment, mobile, and identity, APDU standards remain the norm everywhere.

Why did that happen? The answer is complex, but one major factor surely is the fact that Java Card is for obscure security specialists, and that the smart card protocols are only being exposed to a few developers. In such a context, there is no real need to simplify the interfaces exposed to developers.

What about new markets, though? Are there good reasons to define new APIs rather than new protocols? We can here consider two markets: Mobile TEE and IoT. In both cases, the market is sufficiently new to avoid compatibility issues. Even if standards like GlobalPlatform exist, they are not strong enough yet to be real obstacles.

Let’s start by the mobile TEE. The idea is here to isolate the security functionality of sensitive smartphone applications. By first looking at it, this looks like a fairly open model, where a developer would split an application into the security-sensitive part, which goes in the TEE, and the non-sensitive part, which runs on the “normal” OS. Well, that would work if developers had a clue about how to do this, but it sure isn’t the case. That’s why TEE providers are targeting “security providers”, i.e. developers who are working on security products. However, when taking a closer look, the requirements are always the same: authenticating users, protecting stored data (including keys and other credentials), and getting access to a little crypto to implement proprietary protocols. Most developers do not need in any way a full-fledged TEE with applications and more. All they need is a piece of trusted software that they can leverage in their applications without having to dive too deep in the security part. This may sound good for a supporter of APIs, but I am not sure, as “normal” developers need a generic API for their apps. The way in which these APIs are implemented is not their problem, and it is quite likely that at least part of this implementation will be on the “normal” side. In the end, the usual suspects (security specialists) will be designing the interface between the normal applications and the TEE, and they may be tempted to “optimize” things with low-level protocols.

IoT is different, though. It is interesting for at least two reasons: (1) there is no history and backward compatibility requirements, so why bother with APDUs? and (2) there is a wide variety of devices and applications. In addition, in IoT, we are quite likely to see situations where there is no secure element, so new frameworks have to be designed. Not sure where this is going, but I will sure follow what my ex-colleagues from Oracle are doing with this.

CAP file vs. class file

This debate has been very active during the design of Java Card 3.0 Connected, in which the class file ended up being selected. I was against the decision then, and I am still against it today. The class file is very nice, but it has not been designed with smart card and other limited environments in mind, so it makes perfect sense to design a more optimized format for constrained environments: the CAP file.

Here are a few good reasons to do so:

• Optimization. That’s the obvious one. We can optimize on size by reducing overhead, and we can also optimize on loading and linking times, exploiting Java Card’s limitations on dynamicity.
• Specialized instruction set. This may be considered as a special kind of optimization, but Java Card uses a specific instruction set, which includes in particular a few combined instructions that make programs smaller. This path has definitely not been fully exploited in Java Card.
• Enhanced provability. Java binaries are verifiable, and Java Card could benefit from specific verifications, for instance related to the management of objects. However, Java Card has not exploited this at any point, and bytecode verification has remained more of an issue throughout the years.

On the opposite, from my biased point of view, the only reason to use class files would be to use the same format as anybody else. But since we are not running the same programs, what is the point? Well, there is at least one: with class files, there wouldn’t be a debate about the suitability of bytecode verifiers, as no one is discussing the fact that the Java bytecode verifier is correct.

So, I hope that in the future, the CAP file remains, and that it evolves to integrates more aggressive optimizations, as well as a more sophisticated set of analyses that leverage the specific nature of Java Card code.

Interoperability vs. differentiation

This has been a recurrent discussion item at the Java Card Forum. What should be standardized, and what should be left as differentiators between the actors. Here are a few interesting topics here:

• Basic functionality should be interoperable. That’s been OK for a long time, and nobody dared going back on that one, at least officially. However, there have been some tensions there, in particular around SIM Toolkit. With proactive commands, it is possible to interrupt the execution of a SIM Toolkit routine while waiting for a response from the mobile, and during that time, other commands can be processed. This suspension mechanism, which is essential to the SIM Toolkit spec, has never been formalized in the Java Card platform, leaving an obvious interoperability gap.
• Performance is for differentiation. Another obvious one, although vendors have regularly stymied any effort to define a benchmark for Java Card, like the Mesure project. Performance is a differentiator, but it is better not to measure it correctly.
• Size is for differentiation. That sounds obvious too, but it has led to barrels of fun in real life. Obviously different platforms, even when running on the exact same chip, don’t occupy the same space, so the space left for applications and their data differs. Well, that’s expected, and totally static, so it can easily be considered. Things get more fun when we get to objects. Platforms use headers of different sizes, they don’t implement redundancy in the same way, the don’t manage memory in the same way. In the end, the same set of objects doesn’t occupy the same memory space on two different platforms, and this has been a great issue when cards are almost full.
• Security is not much for differentiation. At first, this looks like a good opportunity for differentiation, as vendors want to be able to claim that their products are “more secure” than their competitor’s products. As an evaluator, I noticed the wide differences in security features between the products, and implicitly supported this view. I now believe that standards are more important for security than differentiation. If we consider the mobile payment vertical, some people will claim that the combination of private platform certifications by Visa and others and of formal Common Criteria certifications bring the desired level of interoperability. Yet, in many cases, certification authorities want to see an application certified on every target platform, and rightly so, because the various platforms do not provide the same guarantees on individual functions; they globally achieve the desired global level of security, but they protect individual functions differently. In order to reduce this, I have pushed for security interoperability to be included in Java Card for many years, first by defining security annotations, and more recently by defining dedicated security APIs. The Protection Profile for Java Card 3.0.5 has not been released yet, so I can’t tell for sure, but I am afraid that the measures included in the latest specification will still not be sufficient to provide sufficient interoperability.

Another interesting thing about interoperability, as we are moving to a world where Java Card may be used on very different platforms: When we defined the Connected Edition, it was very different from the Classic Edition, but we nevertheless stated very stringent interoperability requirements: All Classic applications must run on a Connected platform.

As we may be moving toward another split of Java Card platforms with the rise of RAM-based platforms, I would like to see less stringent requirements. If we consider that Java Card Next will include a Classic and a RAM edition, I would require the following:

• Java Card Next Classic is just the next version following Java Card 3.0.5 Classic. Therefore, backward compatibility must be strict: all Java Card 3.0.5 Classic applications must run unchanged on a Java Card Next Classic platform, even without a recompile.
• Java Card Next RAM is a new platform. Applications developed specifically for this platform are only expected to run on that platform.
• Java Card Next Classic and Java Card Next RAM must be interoperable. It must be possible to write an application that runs on all Java Card Next platforms (Classic and RAM).

For an application provider, this would mean that the following options are available:

• Keep existing applications, and only support their deployment on Java Card Next Classic platforms (in addition to all previous Classic platforms). This could for instance make perfect sense for payment cards or identity cards, which will remain based on classical smart card chips.
• Write new applications specifically for the RAM platform, and only run them on Java Card Next platforms. This is suitable for applications without a strong history, which need to leverage the specific features of RAM platforms, for instance on a mobile TEE.
• Rewrite/write applications that work on both platforms. This is suitable for new applications that target a wide range of devices, like in IoT, where the same application coudl run on many different architectures.

Interoperability discussions are among the most obscure and technical in the Java Card community. It is a bit like politics: it is very easy to make broad statements that sound definitive, but reality is closer to economics, very complex and requires a deep technical understanding (and like economics, it is not a hard science, so debates can be very long). I’ll miss these discussions.

These 20 years have been quite an interesting ride. Java Card is an amazing technology, just as successful as it is understated. Java Card has been deployed on over 15 billion devices since the first deployments in 2000, its deployment numbers have been growing steadily for 15 years. With the current movements in the SIM industry, it is hard to guarantee that this growth will be sustained over the next years, but Java Card is at least guaranteed to have a very fat and very long tail before it disappears.

I will publish a few entries on Java Card, starting here with a few comments on how improbable this success has been over the years.

An immature technology for an immature industry

Initial work on Java Card started in 1996 at Schlumberger’s research team (now part of Gemalto), as all card vendors were looking for solutions to run scripts on smart cards, mostly for supporting the SIM Toolkit framework. At the time, every major vendor had developed a proprietary solution, usually based on an existing programming framework.

In 1997, smart card issuers were starting to ask for interoperability between vendors. The Java Card Forum was founded in the spring as an answer, although few of its members were convinced that it was the way to go forward. Sun Microsystems was invited as owner of the Java technology, smart card vendors became Java Card licensees, and Sun Microsystems took the responsibility of managing the specification and related technologies (reference implementation and compliance kit). Sun didn’t have any experience about smart cards, and in the first meetings, their representatives clearly showed it. Sun then hired Integrity Arts (a Gemplus spin-off) as consultant, and rapidly acquired them, getting expertise in-house.

Java was not well suited to the smart cards available then. The language was easy to learn, but the virtual machine brought an overhead in both size and performance. At the time, it would have been possible to design a more suitable standard for programming smart cards, but the industry has not been able to organize in order to define such a standard.

Java Card became an API specification rapidly with version 2.0, but this version was short-lived, and quickly replaced by version 2.1, which also included a virtual machine specification, and allowed binary Interoperability between products. At about that time, the mobile operators became really interested, a SIM toolkit API was defined, and the deployment began around 2000.

15 years later, this adoption of a poorly adapted technology by an immature industry has become an asset. Because Java Card was a bit too ambitious at the time, and thanks to the continuing success of the Java language, Java Card has now become a mainstream technology, which in 2015, fits the needs of the smart card market, and is present on most open smart cards, and roughly half of the microprocessor cards sold worldwide. In the end, it pays to be inadapted.

Mostly an ecosystem

In the late 1990’s, the first marketing sentences for Java Card were directly taken from Java, like “Millions of developers”, or “Write once, run anywhere”. The one specific marketing argument was about “Running multiple applications on your card”. Fifteen years later, here is a factual status:

• Hundreds of developers (tens of expert developers), mostly working for smart card vendors or for a few specialized consulting firms.
• Most applications written for a single card, or at least for a single issuer.
• Most applications written by a card vendor, and running only on a single vendor’s cards.
• Most cards running a single application.

The next question is: why is Java Card still around if it is not used? Well, in fact, it is being used, just not in the ways that people initially planned. In fact, an essential factor in the success of Java Card has been the certification of cards. In many cases, once a card is deployed, there is no (efficient) procedure to update the card to fix a bug or a vulnerability. Therefore, cards are heavily tested before to be deployed, and most vendors require several levels of certification, including a functional certification and a security certification.

These certification processes are costly, both in developer resources and in laboratory fees. Over the years, efficient certification has become an essential aspect of card development, and Java Card facilitated this in several ways:

• A reference for core functionality. The Java Card specification defines a set of core functions which can then be used to develop applications (cryptography, I/O, storage, appication isolation and sharing). It then becomes possible to test separately these core functions (by evaluating a Java Card platform) and the application using them (by evaluating a Java Card applet). This can lead to economies of scale.
• Reference applications. Some issuers and actors, notably Visa, have written reference versions of their applications, which have been thoroughly tested on compliant Java Card implementations. Vendors who use these reference implementations can simplify the certification process.
• Building experience beyond developers. Laboratories, certification authorities, security consultants all have worked with many Java Card platforms and applications over the years, and now feel confident about their ability to use, test and certify such cards in different configurations. This is the ecosystem part.

In the past few years, the strength of this ecosystem has been a key asset for Java Card, together with the fact that it remains today the dominant platform for defining APIs for smart cards, regardless of the target vertical (once again an ecosystem aspect).

Not dead, not frozen, just slow and conservative

Another striking feature of Java Card is its lack of evolution. The core features of the platform have remained vastly unchanged since release 2.1. Several attempts to make the platform evolve have failed over the years:

• Java Card RMI was introduced with Java Card 2.2, with the objective of making it easier to design new smart card applications, but it was never adopted by the community. Support of Java Card RMI has been optional in the latest releases, and it was close from being deprecated a few times.
• Java Card 3.0 Connected was a bolder attempt at reaching new markets, this time arounod Smart Card Web Servers. This specification is very nice, and it defines a Web application model that can be implemented in half a megabyte, all included (OS, VM, Web container, content management, and a few apps). Yet, smart card web servers never caught, and this specification has never been implemented in a real product since its 2009 release.
• An annotation framework for security interoperability was added recently, but the industry hasn’t been able to agree on a semantics for these annotations, and it has not been adopted.

In the latest 3.0.5 release, we have attempted to add a few simple things, hoping that they will be adopted, but this will only happen in a while, because of another interesting specificity of Java Card. It takes around a year to develop a new platform after the release of a specification, at least another year to get a full certification (functional and security), and another year to sell, produce and deploy it. That’s about 3 years between the specification and the actual availability of products.

This development rate partly explains the slow evolution of Java Card. The smart card ecosystem globally evolves very slowly, and to observers who are used to Web-like evolution, it may look life completely frozen. However, it keeps evolving at its specific and very slow rate. Since 2009, Java Card has become much better adapted to contactless cards, it has adopted a number of cryptographic technologies, and a few other features have evolved to follow the evolution of smart card hardware. Such changes are invisible to the non-specialist, but they keep the Java Card framework in synch with smart card technology, and this is what really counts.

• 1996, Java on a smart card. That’s even more than 15 years ago, and that’s when some maniacs at Schlumberger’s Austin lab came up with the crazy idea of putting a Java virtual machine on a microcontroller with under 1k of RAM. It worked, and that was Cyberflex.
• 1997: the industry organizes. The Java Card Forum is created in April, and the Java Card 2.0 is released, with two demos at Cartes, Cyberflex and GemXpresso. Cyberflex gets the Sesames award that they deserved. Also, Java Card becomes a bit more Java-like, with data stored in objects rather than files, applets, and a few more things.
• 1998: OpenPlatform is created. OpenPlatform has been created by Visa, as the first initiative from issuers to work on the management of multi-application cards. A spec is rapidly issued, which is the ancestor of today’s GlobalPlatform Card Specification.
• 1999: Java Card 2.1 and interoperability. We took more time to release 2.1, because this was the release. The new features include binary interoperability, with the definition of the CAP file, the finalization of the application model, including transient objects and sharing.
• 1999: The SIM Toolkit API is released. This is the first hit for Java Card, which has been essential to its success in the mobile industry, still present in billions of cards.
• 2001: SIM Alliance release Interoperability Stepping Stones. This is a major industry forum, representing vendors, issuing a document that removes them a potential differentiation. Interoperability is not just for geeks any more.
• 2002: Java Card and RMI. This has been a long story, starting with the 1997 Cartes demo by Gemplus. Five years later, RMI gets in the Java Card spec as a mandatory feature, allowing Java Card developers to go beyond APDUs. Or not.
• 2009: Java Card 3.0, Connected Edition. That’s the end of a cycle in which we add more and more features. Starting in 2002 from forecasts of 1Mb chips in 2006 and a big need for content on cards, we went to high-speed communication, better VM, and a Web server. In the end, we had an iPhone, and rather small chips. And enough new features to last for 10 years.
• 2001: The first CC certificate. The Vocable was a bit crazy. Launched in 2000, the idea was to get a Common Criteria certification for a Java smart card. It was highly experimental, training the evaluation lab Serma about Java software, even discussing principles with the certification authority. But it worked, and we got the certificate. Certification matters.
• 2003: The Java Card Protection Profile. This initiative has defined a common base for the certification of Java Card products, and one of the most commonly used PPs, even today. It has also helped us grow a security ecosystem around the security of Java Card.
• 2010: EMVCo certifies a Java Card platform. It took a long time to convince issuers that it was interesting to certify platforms as well as applications. What got them there is NFC, because they now have to share a platform selected by others. And this is a great move ahead, because it is a first step toward security interoperability. We are not there yet, but Java Card is slowly getting there.
• 2009: NFC wallets require Java Card. This is important, because NFC is the first market in which Java Card is an obvious choice. Nobody has discussed this choice, since interoperability and openness are key properties. A very strong use case for Java Card.
• 2012: Embedding the card. With M2M and NFC embedded secure elements, there are talks about embedding Java Card. Once again, this is a strong use case, as the ability to add or update applications is important in this context. In a riskier move, I can mention eUICC, although network operators don’t like this much. The big news about embedded? It changes the control of the secure element, giving more power to device vendors, and taking it away from issuers.
• 2015: The Internet of Things. That’s a natural step. Everybody is talking about these billions of connected devices. At least some of them will need security, and Java Card will be around to provide this. It is recognized, and not linked to a single technology.
• 2020 and beyond: The security subsystem. That’s a bit far to bet on form factors, and I don’t know if secure elements will still be around, if they will be integrated in the main chipsets, or if software only will be needed, but I am convinced that a security subsystem will be around, and Java Card is a good candidate to run on it. Why? Because Java Card is small and constrained, but it is also provable in many ways, and can be evaluated with high assurance levels. And in security terms, these things matter.

To conclude, what is happening today? Well, Java Card security is drawing some interest from the research community, and we are seeing great results. For instance, Guillaume Barbu has done great work in his Ph.D. thesis about logical attacks and countermeasures. More work is happening at Limoges, Nijmegen, Royal Holloway, and more. Students who work on that then get jobs at evaluation labs, and we got presentations from Emilie Faugeron and Jean-Baptiste Machemie about new evaluation offers.

Of course, Java Card is everywhere around NFC, and it was present, explicitly or implicitly, in most presentations I saw from the NFC World Congress.

Finally, a personal note or this blog. I have been personnally involved almost full time on Java Card fornthe past 15 years, and I participated in a way or another to most of the events noted here, except of course the initial idea from the Schlumberger guys. I am very proud of everything we have achieved during these years, and I hope that many more people are just as proud of this success. After all, over 10,000,000,000 cards with Java Card have been produced, and this is a big number. Actually, I don’t know of any application framework that can show such numbers. So thank you everybody, and let’s continue for 15 more years!

Although this draft was officially authored by Sun Microsystems, Schlumberger played an important role there. This is why I am quite sure that the spec was released at the end of the month, since one of Schlumberger’s main patents on the topic was filed on October 25, 19996. The main topic of this patent is to use a high-level language to program a microcontroller, and it claims in particular the transformation of a class file into a more optimized format. Quite a good idea, at least sufficient to include this patent in the suit against Google‘s Android (which may be a proof that Android is yet another derivative of Java Card).

Good idea, but everybody trying to fit something on a card was ddoing just the same. The really brilliant idea was not to generate an optimized format, but to believe that it would be possible to start from something as different as Java. This was brilliant at the time, especially since in 1996, Java was definitely not mainstream technology, and was often considered as too expensive or too slow even on a PC. Now, that’s something for which the guys in Schlumberger can be congratulated.

Of course, they were not the only ones to try fitting unlikely things into a smart card. Researchers in Gemplus were more focused on object oriented technology, in particular Corba. And naturally, they needed to think about optimization in order to fit this into a card. They were using Forth as their base language for the Combo virtual machine. Even before that, as mentioned in this history of bytecode interpreters for smart cards, researchers at RD2P designed a bytecode interpreter, as early as 1990 (I can’t even imagine the memory sizes of cards at that time; if somebody knows, please leave a comment).

Now, the interesting part is that a patent has been filed in France (sorry, in French only). And one of the key elements of this patent was the fact that the programs are later compiled for the specific embedded virtual machine.

Not quite Java Card, though, because the patent only mentioned direct compilation from source code, not using an intermediary format (a.k.a. Java class file). The difference is slim, and I would be tempted to credit the French guys with the invention of optimized smart card code. However, there is something that the Schlumberger guys did much better: timing. The French patent, filed in 1990, was never extended into an international patent, whereas the American patent has been extended and mainained to this day.

As a final trivia note, did you smile when I mentioned that Android was a derivative of Java Card? Well, very indirectly, but somehow, a little bit. Java Card, after being initiated by Schlumberger, was maintained by Sun Microsystems. Sun’s Java Card team later convinced Sun to develop a slightly larger VM, the KVM, to address very small devices. This VM was then extended into MIDP, which became the leading platform for phones. And everybody knows that the Android team includes a number of ex-Sun employees who used to work on MIDP. So, yes, indeed, Android a a distant heir of Java Card.

The slides were about requirements, and there was one particular slide providing high-level guidelines.

JCF high-level guidelines for JC3.0

I was quite amazed when I found this slide, because it is so close to reality. Let’s look at in more details.

• Reduce delta between Java and Java Card. That was already an objective, and that objective was clearly met. Even though some issues remain, Java Card 3.0 is much closer to Java than the previous versions were.
• Enhance the programmer experience. That item is interesting, and reminds us of the nature of the Java Card Forum. We are a technical-oriented forum, which focuses more on developers than on users. We changed that a bit in the following years, with more focus on end users, as we introduced the Web server interface, a clear successor to the text-based SIM Toolkit user interface.
• Fully exploit the 32-bit platform. Check. that was one of the starting points, and we of course achieved that. The Connected Edition explicitly targets 32-bit platforms.
• Keep an eye on the footprint. Uh oh. I knew it! Footprint was already identified as an issue to track. We did, and we still do, as some detractors are saying that Java Card 3.0 is bloated. I don’t agree, but this deserves a full post.
• Become THE computer. OK, this is our “rule the world” moment; I am not sure that we made that, but we are getting closer to that main objective.
• Assumption: forget about 8-bit? Yes and no. The Connected Edition will not work on a 8-bit card, but we also have kept the Classic Edition, which will allow us to keep issuing traditional Java Card cards with small memory and 8-bit processors.

A lot of things are already present. The only thing missing, which will take a while to arise, is the Web server. Other than that, the guidelines were not that bad. Nevertheless, it took us seven more years to get a finalized specification out.

Even by today’s standards, these numbers are staggering, and a 10Gb/s link remains 1,000 times higher than the bandwidth that we experience every day. But the really amazing thing is that the initial design of the computers that handle all this data at CERN was made 15 or 20 years ago, when the project started.

In 1988, I was an assistant in an American supercomputing research center, and some researchers there got the mission to make initial designs for the computers that would handle LHC’s American competitor, SSC. Both the research center and the accelerator have failed since then, but I found an interesting definition of that piece of work on a SSC fact sheet:

In concert with industry, the SSC Laboratory is designing ultra fast parallel computing systems capable of processing the equivalent of 10,000 floppy disks of data every second. This cooperative effort is expected to facilitate the entry of high performance electronics into the commercial marketplace.

10,000 floppy disks is around 14Gb, which means that the estimates were off by a factor 20. It looks large, but it’s not that bad. Back then, this number was enormous, as the size of hard drives was still measures in megabytes, and even our largest supercomputer (an ETA-10, the world’s fastest at the time) was only running at a cool 200MHz. Despite this discrepancy between the resources available in 1988 and the target computer (then set for 2003, 15 years later), the scientists determined that, if Moore’s Law remained valid, it would be possible to handle such an enormous amount of data. They even provided blueprints for such a system.

On a smaller scale, people who design standards often face the same issue. Between the time work starts on a standard and the time it becomes a mainstream product, several years often have passed. Standard designers must take that parameter into account from day 1. This is a tough job, and it is even tougher in “extreme” industries, where the constraints are strong. Supercomputing is at one end of the spectrum, and smart cards are at the other end.

The trade-off is not that simple to make. If we underestimate the evolution of computing power, we limit the possible exploitation of the nex technology, and hence, its value. On the other hand, if we overestimate the evolution of womputing power, we may end up with a technology that cannot be mapped into products (because whatever we designed does not fit on a smart card chip).

When we started the work on Java Card 3, I was afraid to be exactly in that situation. I gradually changed my mind, although I still have a little voice that tells me that we could have done a bit more on the optimization side. Well, as of today, the technology can be implemented, which is good news. However, it requires the largest chips available on the market (i.e., the most expensive). The software is not cheap, either, because Java Card 3 is the largest smart card system around (i.e., the most expensive).

The next step is to transform the technology into successful products. There are usually two ways to do that, but here, we most likely will have to combine them: first, we have to make the added value of the product visible, in order to convince our customers to pay more (at least for the software), and then we have to wait a little in orer to let the price of chips go down.

This may look difficult, but it is definitely achievable. The history of smart cards include plenty of products that were at some point too large, too expensive, or both. And in many cases (Java Card, SIM Toolkit, and others), these technologies often ended up in millions (or billions) of cards.

The hard part is that we now face a few years of hard work promoting Java card 3, making good products, and finding good applications. And only then, there will be another successful product on that list.

If you look at it in detail, you can see that, although the demo was quite hot during the show, we did not get the hottest card design available. The motto, The power of Java in your pocket, is not that great. But still, we were very proud of them.

Another thing that we were very proud of was our demo. There were actually several demos showing, and one of them was showing off the wonders of RMI on smart cards, using actual code, and wonderfully interactive windows. Here is one of them:

Now that I think of it, this demo was really daring, and there haven’t been many demos like that at Cartes. Even for Java Card 3, Gemalto has show some cards at Cartes, but their demo was focused on applications, not on code. Only Oberthur had a demo with JSP technology that was based on the same idea: yes, we made this technology fit in a smart card. And I loved it.

Gemalto, though, has shown other demos with code, but not at Cartes. For instance, we have seen some demos with code last May at JavaOne, and it felt great. I don’t have screen dumps for these demos, but I can still show you the design of the card:

I don’t know if they did it on purpose, but it strangely resembles the original GemXpresso card, with a blue background and a yellow-orange area for the motto. In the inside, however, things were quite different, ajd just as innovative.

I will try to bring more pictures of “historical” cards and other material. Because of my CV, I have more information about Gemplus cards, but I would welcom bits of histories from other companies of the time, like Schlumberger, Delarue, and others.

Browsing through the articles, I found that one of them was in fact about writing program for the original Cyberflex, based on the Java Card 1.0 specification (BTW, I am still desperately looking for a PDF of that spec). As first things come first, I will start by commenting this piece of Java Card history.

The article is titled Get a jumpstart on Java Card, and it was written by Rinaldo di Giorgio. It describes the Cyberflex card, and provides a few hands-on examples of Java Card applications.

I can’t resist copying a small program here, so here is their second example, which will verify a CHV (PIN code):

public class Verifchv {

// Constants used throughout the program
static final byte ACK_CODE = (byte)0;
static final byte BUFFER_LENGTH = 32;
static final byte ISO_COMMAND_LENGTH = (byte)5;

public static void main () {

// Reset the RST bootstrap pointer to the ROM bootstrap
     _OS.Execute((short)0, (byte)0);
    byte bReturnStatus; 

      byte pbuffer[] = new byte[ISO_COMMAND_LENGTH];
      byte dbuffer[] = new byte[BUFFER_LENGTH];



 /////////////////////////////////////////////////////////
 //  Look for a message that contains the correct key
 /////////////////////////////////////////////////////////

 while (true) {
        // Command w/ right chv is 
        // pBuffer = C0 20 00 01 08
        // dBuffer = 48 49 4A 4B 4C 4D 4E 4F
            _OS.GetMessage(pbuffer,
                           ISO_COMMAND_LENGTH, ACK_CODE);

        bReturnStatus =
           _OS.VerifyCHV(pbuffer[3], dbuffer, (byte)0x00);
        _OS.SendStatus((byte)bReturnStatus);
        ///////////////////////////////////////////////
        // Give the user access and/or data based
        // on success or failure of the CHV
        ///////////////////////////////////////////////
        }
    }
}

Well, that’s quite different from what we know today. Let’s comment a few of the important pars of it.

public class Verifchv {

That’s from far the most significant part of the code. It reminds us that we are looking at a Java program, not a native program. The most important contribution of Cyberflex and Java Card 1.0 has been to show that the Java Virtual Machine could run on a smart card, even with very small memory. This was really innovative: remember that, at that time, Java mostly consisted of applets, running on workstations. Even Java ME did not exist (in fact, Java ME is an an indirect consequence of Java Card, but this is another story). Thinking that this big system could run on a card was a great idea.

public static void main () {

Java Card 1.0 is Java, but only for the virtual machine. Because of size and performance constraints, everything is basically static in this specification, so the source code ends up looking a lot like C code.

 while (true) {

At the heart of a Java Card 1.0 program, there is an infinite loop. This loop is still here, but it is now part of the JCRE. These first applications completely controlled the card, just like a native program would. An application would only release control to the system through a specific API.

bReturnStatus =
     _OS.VerifyCHV(pbuffer[3], dbuffer, (byte)0x00);

In Java Card 1.0, the operating system also kept the traditional structure of a smart card OS, based on ISO 7816, file systems, etc. We see here an example, with a function that performs a VERIFY CHV command.

The article also shows that the Cyberflex defined many features that were really innovative:

• It introduces the notion of conversion of class files to an optimized format, through a post-processor.
• It introduces the notion of multiple entities represented on a card to manage applications.

At the end of the day, this article reminds us that Java Card 1.0 has been a very significant contribution to the history of smart card, and Schlumberger’s Austin team should get full credit for that. It also reminds us that innovation is a stepwise process, that it takes a long time to build a new system and to get past the existing technology, and that Java Card 2.0 also was an important step ahead.

Many of the concepts that are still around in Java Card 2.2 were already there: the subset of the Java language, the firewall between applications, the applet model and lifecycle, most of the basic APIs. These concepts have evolved, but the principles have remained the same.

There were also quite a few differences:

• Java Card 2.0 does not define a virtual machine. After heated discussions, the decision was to only define interoperability at the source code level and class file level, but to keep proprietary binary formats. That decision was appropriate for a first release; it was reversed for Java Card 2.1, which had more industrial objectives.
• Java Card 2.0 includes a file system API. .This API was later removed, because of the difficulty to define an API that meets the needs of all industries. Retroactively, this API was a good idea, as it provided an alternative to byte arrays for storing information.
• Transience and sharing were object properties. The API allowed objects to be made transient or to be shared with other applications after their creation. Very flexible, but definitely not the best solution around, as it was difficult to manage.
• There were three kinds of transient objects, including “APDU”-scope objects. This scope later disappeared, although it has a clear use case for security.
• The key hierarchy is based on actual classes rather than interfaces and factories. This is definitely not future-proof, and it drastically evolved in Java Card 2.1.

So, overall, I still believe that we can be very proud of this work. The later evolutions in the API were natural, and it reminds you that the main contribution of Java Card 2.1 is the clear definition of the virtual machine and runtime environment.

The first interesting is that there still is a Java Card 2.0 product page on Sun’s web site. Most of the content is gone, because it is supposed to be stored on some javasoft Web site. However, one piece can be saved, the Applet Developer’s Guide, which happen to be available in a HTML version.

More interesting, some guy has an image of the Java Card FTP repository around the end of 1997, including Godfrey Di Giorgi’s release notes for an intermediary release. Actually, the guy has a complete mirror of the ftp.javasoft.com site, with a lot of fun memories.

I will come back to the content of these specs and the amazingly fast work we did 10 years ago (a full spec produced and published in under 6 months), hopefully before the 10th anniversary of the Java Card 2.0 official release.