WO1998019237A1 - Using a high level programming language with a microcontroller - Google Patents

Using a high level programming language with a microcontroller Download PDF

Info

Publication number
WO1998019237A1
WO1998019237A1 PCT/US1997/018999 US9718999W WO9819237A1 WO 1998019237 A1 WO1998019237 A1 WO 1998019237A1 US 9718999 W US9718999 W US 9718999W WO 9819237 A1 WO9819237 A1 WO 9819237A1
Authority
WO
WIPO (PCT)
Prior art keywords
integrated circuit
application
card
circuit card
byte
Prior art date
Application number
PCT/US1997/018999
Other languages
French (fr)
Inventor
Timothy J. Wilkinson
Scott B. Guthery
Ksheerabdhi Krishna
Michael A. Montgomery
Original Assignee
Schlumberger Systemes
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Family has litigation
First worldwide family litigation filed litigation Critical https://patents.darts-ip.com/?family=21846980&utm_source=google_patent&utm_medium=platform_link&utm_campaign=public_patent_search&patent=WO1998019237(A1) "Global patent litigation dataset” by Darts-ip is licensed under a Creative Commons Attribution 4.0 International License.
Application filed by Schlumberger Systemes filed Critical Schlumberger Systemes
Priority to JP10520562A priority Critical patent/JP2000514584A/en
Priority to AU49118/97A priority patent/AU722463B2/en
Priority to BR9713267-5A priority patent/BR9713267A/en
Priority to DE69714752.5T priority patent/DE69714752C5/en
Priority to EP97911833A priority patent/EP0932865B1/en
Publication of WO1998019237A1 publication Critical patent/WO1998019237A1/en
Priority to HK00100664A priority patent/HK1021762A1/en

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • G06F8/44Encoding
    • G06F8/443Optimisation
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/50Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
    • G06F21/52Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity ; Preventing unwanted data erasure; Buffer overflow
    • G06F21/53Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity ; Preventing unwanted data erasure; Buffer overflow by executing in a restricted environment, e.g. sandbox or secure virtual machine
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/60Protecting data
    • G06F21/62Protecting access to data via a platform, e.g. using keys or access control rules
    • G06F21/6218Protecting access to data via a platform, e.g. using keys or access control rules to a system of files or objects, e.g. local or distributed file system or database
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/70Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer
    • G06F21/71Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure computing or processing of information
    • G06F21/77Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure computing or processing of information in smart cards
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/70Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer
    • G06F21/78Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure storage of data
    • G06F21/79Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure storage of data in semiconductor storage media, e.g. directly-addressable memories
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/52Binary to binary
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/445Program loading or initiating
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/445Program loading or initiating
    • G06F9/44557Code layout in executable memory
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/455Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/455Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45533Hypervisors; Virtual machine monitors
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46Multiprogramming arrangements
    • G06F9/54Interprogram communication
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06QINFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
    • G06Q20/00Payment architectures, schemes or protocols
    • G06Q20/30Payment architectures, schemes or protocols characterised by the use of specific devices or networks
    • G06Q20/34Payment architectures, schemes or protocols characterised by the use of specific devices or networks using cards, e.g. integrated circuit [IC] cards or magnetic cards
    • G06Q20/355Personalisation of cards for use
    • G06Q20/3552Downloading or loading of personalisation data
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06QINFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
    • G06Q20/00Payment architectures, schemes or protocols
    • G06Q20/30Payment architectures, schemes or protocols characterised by the use of specific devices or networks
    • G06Q20/34Payment architectures, schemes or protocols characterised by the use of specific devices or networks using cards, e.g. integrated circuit [IC] cards or magnetic cards
    • G06Q20/356Aspects of software for card payments
    • G06Q20/3563Software being resident on card
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06QINFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
    • G06Q20/00Payment architectures, schemes or protocols
    • G06Q20/30Payment architectures, schemes or protocols characterised by the use of specific devices or networks
    • G06Q20/34Payment architectures, schemes or protocols characterised by the use of specific devices or networks using cards, e.g. integrated circuit [IC] cards or magnetic cards
    • G06Q20/357Cards having a plurality of specified features
    • G06Q20/3574Multiple applications on card
    • GPHYSICS
    • G07CHECKING-DEVICES
    • G07FCOIN-FREED OR LIKE APPARATUS
    • G07F7/00Mechanisms actuated by objects other than coins to free or to actuate vending, hiring, coin or paper currency dispensing or refunding apparatus
    • G07F7/08Mechanisms actuated by objects other than coins to free or to actuate vending, hiring, coin or paper currency dispensing or refunding apparatus by coded identity card or credit card or other personal identification means
    • G07F7/10Mechanisms actuated by objects other than coins to free or to actuate vending, hiring, coin or paper currency dispensing or refunding apparatus by coded identity card or credit card or other personal identification means together with a coded signal, e.g. in the form of personal identification information, like personal identification number [PIN] or biometric data
    • G07F7/1008Active credit-cards provided with means to personalise their use, e.g. with PIN-introduction/comparison system
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00Network arrangements or protocols for supporting network services or applications
    • H04L67/01Protocols
    • H04L67/02Protocols based on web technology, e.g. hypertext transfer protocol [HTTP]
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L9/00Cryptographic mechanisms or cryptographic arrangements for secret or secure communications; Network security protocols
    • H04L9/40Network security protocols
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04WWIRELESS COMMUNICATION NETWORKS
    • H04W12/00Security arrangements; Authentication; Protecting privacy or anonymity
    • H04W12/03Protecting confidentiality, e.g. by encryption
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04WWIRELESS COMMUNICATION NETWORKS
    • H04W12/00Security arrangements; Authentication; Protecting privacy or anonymity
    • H04W12/06Authentication
    • H04W12/062Pre-authentication
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F2221/00Indexing scheme relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F2221/21Indexing scheme relating to G06F21/00 and subgroups addressing additional information or applications relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F2221/2141Access rights, e.g. capability lists, access control lists, access tables, access matrices
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F2221/00Indexing scheme relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F2221/21Indexing scheme relating to G06F21/00 and subgroups addressing additional information or applications relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F2221/2153Using hardware token as a secondary aspect
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00Network arrangements or protocols for supporting network services or applications
    • H04L67/01Protocols
    • H04L67/131Protocols for games, networked simulations or virtual reality
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
    • H04L69/30Definitions, standards or architectural aspects of layered protocol stacks
    • H04L69/32Architecture of open systems interconnection [OSI] 7-layer type protocol stacks, e.g. the interfaces between the data link level and the physical level
    • H04L69/322Intralayer communication protocols among peer entities or protocol data unit [PDU] definitions
    • H04L69/329Intralayer communication protocols among peer entities or protocol data unit [PDU] definitions in the application layer [OSI layer 7]

Definitions

  • This invention relates in general to the field of programming, and more particularly to using a high level programming language with a smart card or a microcontroller.
  • Software applications written in the Java high-level programming language have been so designed that an application written in Java can be run on many different computer brands or computer platforms without change. This is accomplished by the following procedure.
  • a Java application is written, it is compiled into "Class" files containing byte codes that are instructions for a hypothetical computer called a Java Virtual Machine. An implementation of this virtual machine is written for each platform that is supported.
  • the class files compiled from the desired application is loaded onto the selected platform.
  • Java virtual machine for the selected platform is run, and interprets the byte codes in the class file, thus effectively running the Java application.
  • Java is described in the following references which are hereby incorporated by reference: (1) Arnold, Ken, and James Gosling, "The Java Programming Language, “ Addison-Wesley, 1996; (2) James Gosling, Bill Joy, and Guy Steele, "The Java Language Specification, " Sun Microsystems, 1996, (web site: http://java.sun.com/doc/language_specification) ; (3) James Gosling and Henry McGilton, "The Java Language Environment: A White Paper,” Sun Microsystems, 1995 (web site: http://java.sun.com/doc/language_environment/); and (4) Tim Lindholm and Frank Yellin, "The Java Virtual Machine Specification,” Addison-Wesley, 1997.
  • Microcontrollers differ from microprocessors in many ways.
  • a microprocessor typically has a central processing unit that requires certain external components (e.g., memory, input controls and output controls) to function properly.
  • a typical microprocessor can access from a megabyte to a gigabyte of memory, and is capable of processing 16, 32, or 64 bits of information or more with a single instruction.
  • a microcontroller includes a central processing unit, memory and other functional elements, all on a single semiconductor substrate, or integrated circuit (e.g., a "chip").
  • the typical microcontroller accesses a much smaller memory.
  • a typical microcontroller can access one to sixty- four kilobytes of built-in memory, with sixteen kilobytes being very common .
  • RAM random access memory
  • ROM read only memory
  • EEPROM electrically erasable programmable read only memory
  • ROM is the least expensive, it is suitable only for data that is unchanging, such as operating system code.
  • EEPROM is useful for storing data that must be retained when power is removed, but is extremely slow to write. RAM can be written and read at high speed, but is expensive and data in RAM is lost when power is removed.
  • a microprocessor system typically has relatively little ROM and EEPROM, and has 1 to 128 megabytes of RAM, since it is not constrained by what will fit on a single integrated circuit device, and often has access to an external disk memory system that serves as a large writable, non-volatile storage area at a lower cost that EEPROM.
  • a microcontroller typically has a small RAM of 0.1 to 2.0 K, 2K to 8K of EEPROM, and 8K - 56K of ROM.
  • microcontrollers frequently are used in integrated circuit cards, such as smart cards .
  • Such smart cards come in a variety of forms, including contact-based cards, which must be inserted into a reader to be used, and contactless cards, which need not be inserted.
  • microcontrollers with contactless communication are often embedded into specialized forms, such as watches and rings, effectively integrating the functionality of a smart card in an ergonomically attractive manner.
  • applications for smart cards are typically written in a low level programming language (e.g., assembly language) to conserve memory.
  • the integrated circuit card is a secure, robust, tamper-resistant and portable device for storing data.
  • the integrated circuit card is the most personal of personal computers because of its small size and because of the hardware and software data security features unique to the integrated circuit card.
  • the primary task of the integrated circuit card and the microcontroller on the card is to protect the data stored on the card. Consequently, since its invention in 1974, integrated circuit card technology has been closely guarded on these same security grounds.
  • the cards were first used by French banks as debit cards. In this application, before a financial transaction based on the card is authorized, the card user must demonstrate knowledge of a 4 -digit personal identification number (PIN) stored in the card in addition to being in possession of the card. Any information that might contribute to discovering the PIN number on a lost or stolen card was blocked from public distribution. In fact, since nobody could tell what information might be useful in this regard, virtually all information about integrated circuit cards was withheld.
  • PIN personal identification number
  • each application typically is identified with a particular owner or identity. Because applications typically are written in a low-level programming language, such as assembly language, the applications are written for a particular type of microcontroller. Due to the nature of low level programming languages, unauthorized applications may access data on the integrated circuit card. Programs written for a integrated circuit card are identified with a particular identity so that if two identities want to perform the same programming function there must be two copies of some portions of the application on the microcontroller of the integrated circuit card.
  • Integrated circuit card systems have historically been closed systems.
  • An integrated circuit card contained a dedicated application that was handcrafted to work with a specific terminal application.
  • Security checking when an integrated circuit card was used consisted primarily of making sure that the card application and the terminal application were a matched pair and that the data on the card was valid.
  • the invention features an integrated circuit card for use with a terminal .
  • the integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format.
  • a processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal .
  • New applications may be downloaded to a smart card without compromising the security of the smart card. These applications may be provided by different companies loaded at different times using different terminals. Security is not comprised since the applications are protected against unauthorized access of any application code or data by the security features provided by the Java virtual machine.
  • Smart card applications can be created in high level languages such as Java and Eiffel, using powerful mainstream program development tools. New applications can be quickly prototyped and downloaded to a smart card in a matter of hours without resorting to soft masks. Embedded systems using microcontrollers can also gain many of these advantages for downloading new applications, high level program development, and rapid prototyping by making use of this invention.
  • Implementations of the invention may include one or more of the following.
  • the high level programming language format of the application may have a class file format and may have a Java programming language format .
  • the processor may be a microcontroller. At least a portion of the memory may be located in the processor.
  • the application may have been processed from a second application that has a string of characters, and the string of characters may be represented in the first application by an identifier (e.g., an integer) .
  • the processor may be also configured to receive a request from a requester (e.g., a processor or a terminal) to access an element (e.g., an application stored in the memory, data stored in the memory or the communicator) of the card, after receipt of the request, interact with the requester to authenticate an identity of the requester, and based on the identity, selectively grant access to the element.
  • a requester e.g., a processor or a terminal
  • an element e.g., an application stored in the memory, data stored in the memory or the communicator
  • the memory may also store an access control list for the element.
  • the access control list furnishes an indication of types of access to be granted to the identity, and based on the access control list, the processor selectively grants specific types of access (e.g., reading data, writing data, appending data, creating data, deleting data or executing an application) to the requester.
  • the application may be one of a several applications stored in the memory.
  • the processor may be further configured to receive a request from a requester to access one of the plurality of applications; after receipt of the request, determine whether said one of the plurality of applications complies with a predetermined set of rules; and based on the determination, selectively grant access to the requester to said one of the plurality of applications.
  • the predetermined rules provide a guide for determining whether said one of the plurality of applications accesses a predetermined region of the memory.
  • the processor may be further configured to authenticate an identity of the requester and grant access to said one of the plurality of applications based on the identity.
  • the processor may be also configured to interact with the terminal via the communicator to authenticate an identity; determine if the identity has been authenticated; and based on the determination, selectively allow communication between the terminal and the integrated circuit card.
  • the communicator and the terminal may communicate via communication channels.
  • the processor may also be configured to assign one of the communication channels to the identity when the processor allows the communication between the terminal and the integrated circuit card.
  • the processor may also be configured to assign a session key to the assigned communication channel and use the session key when the processor and the terminal communicate via the assigned communication channel.
  • the terminal may have a card reader, and the communicator may include a contact for communicating with the card reader.
  • the terminal may have a wireless communication device, and the communictor may include a wireless transceiver for communicating with the wireless communication device.
  • the terminal may have a wireless communication device, and the communicator may include a wireless transmitter for communicating with the wireless communication device.
  • the invention features a method for use with an integrated circuit card and a terminal . The method includes storing an interpreter and at least one application having a high level programming language format in a memory of the integrated circuit card.
  • a processor of the integrated circuit card uses the interpreter to interpret the at least one application for execution, and the processor uses a communicator of the card when communicating between the processor and the terminal .
  • the invention features a smart card.
  • the smart card includes a memory that stores a Java interpreter and a processor that is configured to use the interpreter to interpret a Java application for execution.
  • the invention features a microcontroller that has a semiconductor substrate and a memory located in the substrate.
  • a programming language interpreter is stored in the memory and is configured to implement security checks.
  • a central processing unit is located in the substrate and is coupled to the memory.
  • Implementations of the invention may include one or more of the following.
  • the interpreter may be a Java byte code interpreter.
  • the security checks may include establishing firewalls and may include enforcing a sandbox security model .
  • the invention features a smart card that has a programming language interpreter stored in a memory of the card.
  • the interpreter is configured to implement security check.
  • a central processing unit of the card is coupled to the memory .
  • the invention features an integrated circuit card that is used with a terminal .
  • the card includes a communicator and a memory that stores an interpreter and first instructions of a first application.
  • the first instructions have been converted from second instructions of a second application.
  • the integrated circuit card includes a processor that is coupled to the memory and is configured to use the interpreter to execute the first instructions and to communicate with the terminal via the communicator .
  • Implementations of the invention may include one or more of the following.
  • the first and/or second applications may have class file format (s) .
  • the first and/or second applications may include byte codes, such as Java byte codes.
  • the first instructions may be generalized or renumbered versions of the second instructions.
  • the second instructions may include constant references, and the first instructions may include constants that replace the constant references of the second instructions.
  • the second instructions may include references, and the references may shift location during the conversion of the second instructions to the first instructions.
  • the first instructions may be relinked to the references after the shifting.
  • the first instructions may include byte codes for a first type of virtual machine, and the second instructions may include byte codes for a second type of virtual machine. The first type is different from the second type.
  • the invention features a method for use with an integrated circuit card.
  • the method includes converting second instructions of a second application to first instructions of a first application; storing the first instructions in a memory of the integrated circuit card; and using an interpreter of the integrated circuit card to execute the first instructions.
  • the invention features an integrated circuit for use with a terminal .
  • the integrated circuit card has a communicator that is configured to communicate with the terminal and a memory that stores a first application that has been processed from a second application having a string of characters. The string of characters are represented in the first application by an identifier.
  • the integrated circuit card includes a processor that is coupled to the memory. The processor is configured to use the interpreter to interpret the first application for execution and to use the communicator to communicate with the terminal .
  • the invention features a method for use with an integrated circuit card and a terminal.
  • the method includes processing a second application to create a first application.
  • the second application has a string of characters.
  • the string of characters is represented by an identifier in the second application.
  • An interpreter and the first application are stored in a memory of the integrated circuit card.
  • a processor uses an interpreter to interpret the first application for execution.
  • the invention features a microcontroller that includes a memory which stores an application and an interpreter.
  • the application has a class file format.
  • a processor of the microcontroller is coupled to the memory and is configured to use the interpreter to interpret the application for execution.
  • the microcontroller may also include a communicator that is configured to communicate with a terminal .
  • the invention features a method for use with an integrated circuit card.
  • the method includes storing a first application in a memory of the integrated circuit card, storing a second application in the memory of the integrated circuit card, and creating a firewall that isolates the first and second applications so that the second application cannot access either the first application or data associated with the first application.
  • the invention features an integrated circuit card for use with a terminal .
  • the integrated circuit card includes a communicator that is configured to communicate with the terminal, a memory and a processor.
  • the memory stores applications, and each application has a high level programming language format.
  • the memory also stores an interpreter.
  • the processor is coupled to the memory and is configured to: a.) use the interpreter to interpret the applications for execution, b.) use the interpreter to create a firewall to isolate the applications from each other, and c.) use the communicator to communicate with the terminal .
  • FIG. 1 is a block diagram of an integrated card system.
  • Fig. 2 is a flow diagram illustrating the preparation of Java applications to be downloaded to an integrated circuit card.
  • Fig. 3 is a block diagram of the files used and generated by the card class file converter.
  • Fig. 4 is a block diagram illustrating the transformation of application class file(s) into a card class file.
  • Fig. 5 is a flow diagram illustrating the working of the class file converter.
  • Fig. 6 is a flow diagram illustrating the modification of the byte codes.
  • Fig. 7 is a block diagram illustrating the transformation of specific byte codes into general byte codes .
  • Fig. 8 is a block diagram illustrating the replacement of constant references with constants.
  • Fig. 9 is a block diagram illustrating the replacement of references with their updated values.
  • Fig. 10 is a block diagram illustrating renumbering of original byte codes.
  • Fig. 11 is a block diagram illustrating translation of original byte codes for a different virtual machine architecture.
  • Fig 12 is a block diagram illustrating loading applications into an integrated circuit card.
  • Fig. 13 is a block diagram illustrating executing applications in an integrated circuit card.
  • Fig. 14 is a schematic diagram illustrating memory organization for ROM, RAM and EEPROM.
  • Fig. 15 is a flow diagram illustrating the overall architecture of the Card Java virtual machine.
  • Fig. 16 is a flow diagram illustrating method execution in the Card Java virtual machine with the security checks.
  • Fig. 17 is a flow diagram illustrating byte code execution in the Card Java virtual machine.
  • Fig. 18 is a flow diagram illustrating method execution in the Card Java virtual machine without the security checks .
  • Fig. 19 is a block diagram illustrating the association between card applications and identities.
  • Fig. 20 is a block diagram illustrating the access rights of a specific running application.
  • Fig. 21 is a perspective view of a microcontroller on a smart card.
  • Fig. 22 is a perspective view of a microcontroller on a telephone.
  • Fig. 23 is a perspective view of a microcontroller on a key rin .
  • Fig. 24 is a perspective view of a microcontroller on a ring.
  • Fig. 25 is a perspective view of a microcontroller on a circuit card of an automobile.
  • an integrated circuit card 10 (e.g., a smart card) is constructed to provide a high level, Java-based, multiple application programming and execution environment.
  • the integrated circuit card 10 has a communicator 12a that is configured to communicate with a terminal communicator 12b of a terminal 14.
  • the integrated circuit card 10 is a smart card with an 8 bit microcontroller, 512 bytes of RAM, 4K bytes of EEPROM, and 20K of ROM;
  • the terminal communicator 12b is a conventional contact smart card reader;
  • the terminal 14 is a conventional personal computer running the Windows NT operating system supporting the personal computer smart card (PC/SC) standard and providing Java development support .
  • PC/SC personal computer smart card
  • the microcontroller, memory and communicator are embedded in a plastic card that has substantially the same dimensions as a typical credit card.
  • the microcontroller, memory and communicator are mounted within bases other than a plastic card, such as jewelry (e.g., watches, rings or bracelets) , automotive equipment, telecommunication equipment (e.g., subscriber identity module (SIM) cards), security devices (e.g., cryptographic modules) and appliances .
  • jewelry e.g., watches, rings or bracelets
  • telecommunication equipment e.g., subscriber identity module (SIM) cards
  • security devices e.g., cryptographic modules
  • the terminal 14 prepares and downloads Java applications to the integrated circuit card 10 using the terminal communicator 12b.
  • the terminal communicator 12b is a communications device capable of establishing a communications channel between the integrated circuit card 10 and the terminal 14. Some communication options include contact card readers, wireless communications via radio frequency or infrared techniques, serial communication protocols, packet communication protocols, ISO 7816 communication protocol, to name a few.
  • the terminal 14 can also interact with applications running in the integrated circuit card 10. In some cases, different terminals may be used for these purposes. For example, one kind of terminal may be used to prepare applications, different terminals could be used to download the applications, and yet other terminals could be used to run the various applications.
  • Terminals can be automated teller machines (ATM)s, point - of-sale terminals, door security systems, toll payment systems, access control systems, or any other system that communicates with an integrated circuit card or microcontroller.
  • the integrated circuit card 10 contains a card Java virtual machine (Card JVM) 16, which is used to interpret applications which are contained on the card 10.
  • the Java application 20 includes three Java source code files A.java 20a, B.java 20b, and C.java 20c. These source code files are prepared and compiled in a Java application development environment 22. When the Java application 20 is compiled by the development environment 22, application class files 24 are produced, with these class files A. class 24a, B. class 24b, and C.
  • the application class files 24 follow the standard class file format as documented in chapter 4 of the Java virtual machine specification by Tim Lindholm and Frank Yellin, "The Java Virtual Machine Specification, " Addison-Wesley, 1996. These application class files 24 are fed into the card class file converter 26, which consolidates and compresses the files, producing a single card class file 27.
  • the card class file 27 is loaded to the integrated circuit card 10 using a conventional card loader 28.
  • the card class file converter 26 is a class file postprocessor that processes a set of class files 24 that are encoded in the standard Java class file format, optionally using a string to ID input map file 30 to produce a Java card class file 27 in a card class file format.
  • One such card class file format is described in Appendix A which is hereby incorporated by reference.
  • the card class file converter 26 produces a string to ID output map file 32 that is used as input for a subsequent execution of the card class file converter.
  • the card class file converter 26 can accept previously defined string to ID mappings from a string to ID input map file 30. In the absence of such a file, the IDs are generated by the card class file converter 26.
  • Appendix B which is hereby incorporated by reference, describes one possible way of implementing and producing the string to ID input map file 30 and string to ID output map file 32 and illustrates this mapping via an example.
  • a typical application class file 24a includes class file information 41; a class constant pool 42; class, fields created, interfaces referenced, and method information 43; and various attribute information 44, as detailed in aforementioned Java Virtual Machine Specification. Note that much of the attribute information 44 is not needed for this embodiment and is eliminated 45 by the card class file converter 26. Eliminated attributes include SourceFile, ConstantValue, Exceptions, LineNumberTable,
  • the typical card class file 27 as described in Appendix A is derived from the application class files 24 in the following manner.
  • the card class file information 46 is derived from the aggregate class file information 41 of all application class files 24a, 24b, and 24c.
  • the card class file constant pool 47 is derived from the aggregate class constant pool 42 of all application class files 24a, 24b, and 24c.
  • the card class, fields created, interfaces referenced, and method information 48 is derived from the aggregate class, fields created, interfaces referenced, and method information 43 of all application class files 24a, 24b, and 24c.
  • the card attribute information 49 in this embodiment is derived from only the code attribute of the aggregate attribute information 44 of all application class files 24a, 24b, and 24c.
  • the first class file to be processed is selected 51a.
  • the constant pool 42 is compacted 51b in the following manner. All objects, classes, fields, methods referenced in a Java class file 24a are identified by using strings in the constant pool 42 of the class file 24a.
  • the card class file converter 26 compacts the constant pool 42 found in the Java class file 24a into an optimized version. This compaction is achieved by mapping all the strings found in the class file constant pool 42 into integers (the size of which is microcontroller architecture dependent) . These integers are also referred to as IDs.
  • Each ID uniquely identifies a particular object, class, field or method in the application 20. Therefore, the card class file converter 26 replaces the strings in the Java class file constant pool 42 with its corresponding unique ID.
  • Appendix B shows an example application HelloSmartCard. java, with a table below illustrating the IDs corresponding to the strings found in the constant pool of the class file for this application. The IDs used for this example are 16- bit unsigned integers.
  • the card class file converter 26 checks for unsupported features 51c in the Code attribute of the input Java class file 24a.
  • the Card JVM 16 only supports a subset of the full Java byte codes as described in Appendix C, which is hereby incorporated by reference.
  • the card class file converter 26 checks for unsupported byte codes in the Code attribute of the Java class file 24a. If any unsupported byte codes are found 52, the card class file converter flags an error and stops conversion 53.
  • the program code fragment marked "A" in APPENDIX D shows how these spurious byte codes are apprehended. Another level of checking can be performed by requiring the standard Java development environment 22 to compile the application 20 with a ⁇ -g' flag.
  • this option requires the Java compiler to place information about the variables used in a Java application 20 in the LocalVariableTable attribute of the class file 24a.
  • the card class file converter 26 uses this information to check if the Java class file 24a references data types not supported by the Java card.
  • a Java class file 24a stores information pertaining to the byte codes in the class file in the Attributes section 44 of the Java class file. Attributes that are not required for interpretation by the card JVM 16, such as SourceFile, ConstantValue, Exceptions, LineNumberTable, and LocalVariableTable may be safely discarded 45.
  • the only attribute that is retained is the Code attribute.
  • the Code attribute contains the byte codes that correspond to the methods in the Java class file 24a.
  • Modifying the byte codes 54 involves examining the Code attribute information 44 for each method in the class file, and modifying the operands of byte codes that refer to entries in the Java class file constant pool 42 to reflect the entries in the card class file constant pool 47. In some embodiments, the byte codes are also modified, as described below.
  • Modifying the byte codes 54 involves five passes (with two optional passes) as described by the flowchart in Fig. 6.
  • the original byte codes 60 are found in the Code attribute 44 of the Java class file 24a being processed.
  • the first pass 61 records all the jumps and their destinations in the original byte codes.
  • some single byte code may be translated to dual or triple bytes.
  • Fig. 7 illustrates an example wherein byte code ILOAD_0 is replaced with two bytes, byte code ILOAD and argument 0.
  • the original byte codes 60 are analyzed for any jump byte codes and a note made of their position and current destination.
  • the program code fragment marked "B" in Appendix D shows how these jumps are recorded. Appendix D is hereby incorporated by reference.
  • the card class file converter 26 may proceed to the third pass 64. Otherwise, the card class file converter converts specific byte codes into generic byte codes. Typically, the translated byte codes are not interpreted in the Card JVM 16 but are supported by converting the byte codes into equivalent byte codes that can be interpreted by the Card JVM 16 (see Fig. 7) .
  • the byte codes 70 may be replaced with another semantically equivalent but different byte codes 72. This generally entails the translation of short single specific byte codes such as ILOAD_0 into their more general versions. For example, ILOAD_0 may be replaced by byte code ILOAD with an argument 0.
  • This translation is done to reduce the number of byte codes translated by the Card JVM 16, consequently reducing the complexity and code space requirements for the Card JVM 16.
  • the program code fragment marked "C" in Appendix D shows how these translations are made. Note that such translations increase the size of the resulting byte code and force the re-computation of any jumps which are affected.
  • the card class file converter rebuilds constant references via elimination of the strings used to denote these constants.
  • Fig. 8 shows an example wherein the byte code LDC 80 referring to constant "18" found via an index in the Java class file 24a constant pool 42 may be translated into BIPUSH byte code 82.
  • the card class file converter 26 modifies the operands to all the byte codes that refer to entries in the Java class file constant pool 42 to reflect their new location in the card class file constant pool 47.
  • Fig. 9 shows an example wherein the argument to a byte code, INVOKESTATIC 90, refers to an entry in the Java class file constant pool 42 that is modified to reflect the new location of that entry in the card class file constant pool 47.
  • the modified operand 94 shows this transformation.
  • the program code fragment marked "D" in Appendix D shows how these modifications are made .
  • the card class file converter may proceed to the fifth and final pass 67. Otherwise, the card class file converter modifies the original byte codes into a different set of byte codes supported by the particular Card JVM 16 being used.
  • One potential modification renumbers the original byte codes 60 into Card JVM 16 byte codes (see Fig. 10) . This renumbering causes the byte codes 100 in the original byte codes 60 to be modified into a renumbered byte codes 102.
  • Byte code ILOAD recognized by value 21 may be renumbered to be recognized by value 50. This modification may be done for optimizing the type tests (also known in prior art as Pass 3 checks) in the Card JVM 16.
  • the program code fragment marked "E" in Appendix D shows an implementation of this embodiment.
  • This modification may be done in order to reduce the program space required by the Card JVM 16 to interpret the byte code. Essentially this modification regroups the byte codes into Card JVM 16 byte codes so that byte codes with similar operands, results are grouped together, and there are no gaps between Card JVM 16 byte codes. This allows the Card JVM 16 to efficiently check Card JVM 16 byte codes and validate types as it executes.
  • the card class file converter modifies the original byte codes 60 into a different set of byte codes designed for a different virtual machine architecture, as shown in Fig. 11.
  • the Java byte code ILOAD 112 intended for use on a word stack 114 may be replaced by Card JVM 16 byte code ILOAD_B 116 to be used on a byte stack 118.
  • An element in a word stack 114 requires allocating 4 bytes of stack space, whereas an element in the byte stack 118 requires only one byte of stack space. Although this option may provide an increase in execution speed, it risks losing the security features available in the original byte codes.
  • the card class file converter 26 Since the previous steps 63, 64 or 66 may have changed the size of the byte codes 60 the card class file converter 26 has to relink 67 any jumps which have been effected. Since the jumps were recorded in the first step 61 of the card class file converter 26, this adjustment is carried out by fixing the jump destinations to their appropriate values. The program code fragment marked "F" in Appendix D shows how these jumps are fixed.
  • the card class file converter now has modified byte codes 68 that is equivalent to the original byte codes 60 ready for loading.
  • the translation from the Java class file 24a to the card class file 27 is now complete. Referring back to Fig. 5, if more class files 24 remain to be processed 55 the previous steps 51a, 51b, 51c, 52 and 54 are repeated for each remaining class file.
  • the card class file converter 26 gathers 56 the maps and modified byte codes for the classes 24 that have been processed, places them as an aggregate and generates 57 a card class file 27. If required, the card class file converter 26 generates a string to ID output map file 32, that contains a list of all the new IDs allocated for the strings encountered in the constant pool 42 of the Java class files 24 during the translation.
  • the card loader 28 within the terminal 14 sends a card class file to the loading and execution control 120 within the integrated circuit card 10 using standard ISO 7816 commands.
  • the loading and execution control 120 with a card operating system 122, which provides the necessary system resources, including support for a card file system 124, which can be used to store several card applications 126.
  • Many conventional card loaders are written in low level languages, supported by the card operating system 122.
  • the bootstrap loader is written in Java, and the integrated circuit card 10 includes a Java virtual machine to run this application.
  • a Java implementation of the loading and execution control 120 is illustrated in Appendix E which is hereby incorporated by reference.
  • the loading and execution control 120 receives the card class file 26 and produces a Java card application 126x stored in the card file system 126 in the EEPROM of the integrated circuit card 10. Multiple Java card applications 126x, 126y, and 126z can be stored in a single card in this manner.
  • the loading and execution control 120 supports commands whereby the terminal 14 can select which Java card application to run immediately, or upon the next card reset .
  • the Card Java Virtual Machine (Card JVM) 16 upon receiving a reset or an execution command from the loading and execution control 120, the Card Java Virtual Machine (Card JVM) 16 begins execution at a predetermined method (for example, main) of the selected class in the selected Java Card application 126z.
  • the Card JVM 16 provides the Java card application 126z access to the underlying card operating system 122, which provides capabilities such as I/O,
  • the selected Java card application 126z communicates with an appropriate application in the terminal 14 using the communicator 12a to establish a communication channel to the terminal 14.
  • Data from the communicator 12a to the terminal 14 passes through a communicator driver 132 in the terminal, which is specifically written to handle the communications protocol used by the communicator 12a.
  • the data then passes to an integrated circuit card driver 134, which is specifically written to address the capabilities of the particular integrated circuit card 10 being used, and provides high level software services to the terminal application 136. In the preferred embodiment, this driver would be appropriate PC/SC Smartcard Service Provider (SSP) software.
  • SSP PC/SC Smartcard Service Provider
  • the Card JVM 16 is an interpreter that interprets a card application 126x.
  • the memory resources in the microcontroller that impact the Card JVM 16 are the Card ROM 140, Card RAM 141 and the Card EEPROM 142.
  • the Card ROM 140 is used to store the Card JVM 16 and the card operating system 122. Card ROM 140 may also be used to store fixed card applications 140a and class libraries 140b.
  • Loadable applications 141a, 141b and libraries 141c may also be stored in Card RAM 141.
  • the Card JVM 16 interprets a card application 141a, 141b, or 140a.
  • the Card JVM 16 uses the Card RAM to store the VM stack 144a and system state variables 144b.
  • the Card JVM 16 keeps track of the operations performed via the VM stack 144a.
  • the objects created by the Card JVM 16 are either on the RAM heap 144c, in the EEPROM heap 146a, or in the file system 147.
  • All of the heap manipulated by the Card JVM 16 may be stored in the Card RAM 141 as a RAM Heap 144c, or it may be distributed across to the Card EEPROM 142 as a EEPROM Heap 146a.
  • Card RAM 141 is also used for recording the state of the system stack 148 that is used by routines written in the native code of the microcontroller.
  • the Card JVM 16 uses the Card EEPROM 142 to store application data either in the EEPROM heap 146a or in the file system 147.
  • Application data stored in a file may be manipulated via an interface to the card operating system 122. This interface is provided by a class library 140b stored in Card ROM 140, by a loadable class library 141c stored in Card EEPROM 142. One such interface is described in Appendix F. Applications and data in the card are isolated by a firewall mechanism 149.
  • the Card JVM 16 implements a strict subset of the Java programming language. Consequently, a Java application 20 compiles into a class file that contains a strict subset of Java byte codes. This enables application programmers to program in this strict subset of Java and still maintain compatibility with existing Java Virtual Machines.
  • the semantics of the Java byte codes interpreted by the Card JVM 16 are described in the aforementioned Java Virtual Machine Specification.
  • the subset of byte codes interpreted by the Card JVM 16 can be found in Appendix C.
  • the card class file converter 26 checks the Java application 20 to ensure use of only the features available in this subset and converts into a form that is understood and interpreted by the Card JVM 16.
  • the Card JVM 16 is designed to interpret a different set or augmented set of byte codes 116. Although a different byte code set might lead to some performance improvements, departing from a strict Java subset may not be desirable from the point of view of security that is present in the original Java byte codes or compatibility with mainstream Java development tools .
  • All Card JVM 16 applications 126 have a defined entry point denoted by a class and a method in the class. This entry point is mapped in the string to ID input map 30 and assigned by the card class file converter 26.
  • Classes, methods and fields within a Java application 20 are assigned IDs by the card class file converter 26.
  • ID corresponding to the main application class may be defined as F001 and the ID corresponding to its main method, such as "main()V" could be defined as F002.
  • the overall execution architecture of the Card JVM is described by the flowchart in Fig. 15. Execution of the Card JVM 16 begins at the execution control 120, which chooses a card application 126z to execute. It proceeds by finding and assigning an entry point 152 (a method) in this card application for the Card JVM 16 to interpret. The Card JVM 16 interprets the method 153. If the interpretation proceeds successfully 154, the Card JVM 16 reports success 155 returning control back to the execution control 120. If in the course of interpretation 153 the Card JVM 16 encounters an unhandled error or exception (typically a resource limitation or a security violation) , the Card JVM 16 stops 156 and reports the appropriate error to the terminal 14.
  • an unhandled error or exception typically a resource limitation or a security violation
  • An essential part of the Card JVM 16 is a subroutine that handles the execution of the byte codes. This subroutine is described by the flowchart in Fig. 16. Given a method 160 it executes the byte codes in this method. The subroutine starts by preparing for the parameters of this method 161. This involves setting the VM stack 144a pointer, VM stack 144a frame limits, and setting the program counter to the first byte code of the method.
  • the method flags are checked 162. If the method is flagged native, then the method is actually a call to native method code (subroutine written in the microcontroller's native processor code). In this case, the Card JVM 16 prepares for an efficient call 163 and return to the native code subroutine. The parameters to the native method may be passed on the VM stack 144a or via the System stack 148. The appropriate security checks are made and the native method subroutine is called. On return, the result (if any) of the native method subroutine is placed on the VM stack 144a so that it may be accessed by the next byte code to be executed. The dispatch loop 164 of the Card JVM 16 is then entered.
  • the byte code dispatch loop is responsible for preparing, executing, and retiring each byte code.
  • the loop terminates when it finishes interpreting the byte codes in the method 160, or when the Card JVM 16 encounters a resource limitation or a security violation. If a previous byte code caused a branch to be taken 165 the Card JVM prepares for the branch 165a. The next byte code is retrieved 165b. In order to keep the cost of processing each byte code down, as many common elements such as the byte code arguments, length, type are extracted and stored.
  • byte codes in the class file must be verified and determined conformant to this model. These checks are typically carried out in prior art by a program referred to as the byte code verifier, which operates in four passes as described in the Java Virtual Machine Specification.
  • the Card JVM 16 To offer the run-time security that is guaranteed by the byte code verifier, the Card JVM 16 must perform the checks that pertain to the Pass 3 and Pass 4 of the verifier. This checking can be bypassed by the Card JVM 16 if it can be guaranteed (which is almost impossible to do) that the byte codes 60 interpreted by the Card JVM 16 are secure. At the minimum, code security can be maintained as long as object references cannot be faked and the VM stack
  • a 256-byte table is created as shown in Appendix G which is hereby incorporated by reference.
  • This table is indexed by the byte code number.
  • This table contains the type and length information associated with the indexing byte code. It is encoded with the first 5 bits representing type, and the last 3 bits representing length. The type and length of the byte code is indexed directly from the table by the byte code number.
  • This type and length is then used for checking as shown in Appendix H which is hereby incorporated by reference. In Appendix H, the checking process begins by decoding the length and type from the table in Appendix G which is hereby incorporated by reference. The length is used to increment the program counter.
  • the type is used first for pre-execution checking, to insure that the data types on the VM stack 144a are correct for the byte code that is about to be executed.
  • the 256 bytes of ROM for table storage allows the original Java byte codes to be run in the Card JVM 16 and minimizes the changes required to the Java class file to be loaded in the card. Additional Java byte codes can be easily supported since it is relatively easy to update the appropriate table entries .
  • the Java byte codes in the method are renumbered in such a manner that the byte code type and length information stored in the table in Appendix H is implicit in the reordering.
  • Appendix H is hereby incorporated by reference. Consequently, the checks that must be performed on the state of the VM stack 144a and the byte code being processed does not have to involve a table look up. The checks can be performed by set of simple comparisons as shown in Appendix I which is hereby incorporated by reference. This embodiment is preferable when ROM space is at a premium, since it eliminates a 256-byte table. However adding new byte codes to the set of supported byte codes has to be carefully thought out since the new byte codes have to fit in the implicit numbering scheme of the supported byte codes .
  • the Card JVM 16 chooses not to perform any security checks in favor of Card JVM 16 execution speed. This is illustrated in the flowchart in Fig. 18. The flow chart in Fig. 18 is the same as that of Fig. 16 with the security checks removed. This option is not desirable from the point of view of security, unless it can be guaranteed that the byte codes are secure .
  • the Card JVM 16 may enforce other security checks as well. If the byte code may reference a local variable, the Card JVM 16 checks if this reference is valid, throwing an error if it is not. If the reference is valid, the Card JVM 16 stores the type of the local variable for future checking. The VM stack 144a pointer is checked to see if it is still in a valid range. If not an exception is thrown. The byte code number is checked. If it is not supported, an exception is thrown. Finally, the byte code itself is dispatched 165d. The byte codes translated by the Card JVM 16 are listed in Appendix C.
  • byte codes The semantics of the byte codes are described in the aforementioned Java Virtual Machine Specification with regard to the state of the VM stack 144a before and after the dispatch of the byte code. Note also that some byte codes (the byte codes, INVOKESTATIC, INVOKESPECIAL, INVOKENONVIRTUAL and INVOKEVIRTUAL) may cause reentry into the Card JVM 16, requiring processing to begin at the entry of the subroutine 161.
  • Fig. 17 shows the flowchart of the byte code execution routine. The routine is given a byte code 171 to execute. The Card JVM 16 executes 172 the instructions required for the byte code. If in the course of executing the Card JVM 16 encounters a resource limitation 173, it returns an error 156.
  • This error is returned to the terminal 16 by the Card JVM 16. If the byte code executes successfully, it returns a success 175. After execution, the type of the result is used to set the VM stack 144a state correctly 165e, properly flagging the data types on the VM stack 144a. The byte code information gathered previously 165b from the byte code info table is used to set the state of the VM stack 144a in accordance with the byte code that just executed.
  • setting the output state of the VM stack 144a with respect to the byte code executed is simplified if the byte code is renumbered. This is shown in Appendix I which is hereby incorporated by reference.
  • the Card JVM 16 may bypass setting the output state of the VM stack 144a in favor of Card JVM 16 execution speed. This option is not desirable from the point of view of security, unless it can be guaranteed that the byte codes are secure.
  • the byte code is retired 165f. This involves popping arguments off the VM stack 144a. Once byte code processing is completed, the loop 164 is repeated for the next byte code for the method.
  • Termination 167 of the byte code dispatch loop 164 indicates that the Card JVM 16 has completed executing the requested method.
  • the integrated circuit card 10 relies on the firewall mechanism 149 provided by the Card JVM 16. Because the Card JVM implements the standard pass 3 and pass 4 verifier checks, it detects any attempt by an application to reference the data or code space used by another application, and flag a security error 156. For example, conventional low level applications can cast non-reference data types into references, thereby enabling access to unauthorized memory space, and violating security. With this invention, such an attempt by a card application 126z to use a non-reference data type as a reference will trigger a security violation 156. In conventional Java, this protected application environment is referred to as the sandbox application-interpretation environment. However, these firewall facilities do not work independently. In fact, the facilities are overlapping and mutually reinforcing with conventional access control lists and encryption mechanisms shown in the following table :
  • card applications 126x, 126y, 126z can be endowed with specific privileges when the card applications 126 execute. These privileges determine, for example, which data files the card applications 126 can access and what operations the card applications 126 can perform on the file system 147.
  • the privileges granted to the card applications 126 are normally set at the time that a particular card application 126z is started by the user, typically from the terminal 14.
  • the integrated circuit card 10 uses cryptographic identification verification methods to associate an identity 190 (e.g., identities 190a, 190b and 190c) and hence, a set of privileges to the execution of the card application 126.
  • the association of the specific identity 190c to the card application 126z is made when the card application 126z begins execution, thus creating a specific running application 200, as shown in Fig. 20.
  • the identity 190 is a unique legible text string reliably associated with an identity token.
  • the identity token e.g., a personal identification number (PIN) or a RSA private key
  • PIN personal identification number
  • RSA private key is an encryption key. Referring to Fig. 20, in order to run a specific card application 126z, the identity 190c of the card application 126z must be authenticated.
  • the identity 190c is authenticated by demonstrating knowledge of the identity token associated with the identity 190c.
  • an agent e.g., a card holder or another application wishing to run the application
  • an agent e.g., a card holder or another application wishing to run the application
  • One way to demonstrate possession of an encryption key is simply to expose the key itself. PIN verification is an example of this form of authentication.
  • Another way to demonstrate the possession of an encryption key without actually exposing the key itself is to show the ability to encrypt or decrypt plain text with the key.
  • a specific running application 200 on the integrated circuit card 10 includes a card application 126z plus an authenticated identity 190c. No card application 126 can be run without both of these elements being in place.
  • the card application 126z defines data processing operations to be performed, and the authenticated identity 190c determines on what computational objects those operations may be performed. For example, a specific application 126z can only access identity C's files 202 in the file system 147 associated with the specific identity 190c, and the specific card application 126z cannot access other files 204 that are associated with identities other than the specific identity 190c.
  • the integrated circuit card 10 may take additional steps to ensure application and data isolation.
  • the integrated circuit card 10 furnishes three software features sets: authenticated-identity access control lists; a Java-based virtual machine; and one-time session encryption keys to protect data files, application execution, and communication channels, respectively. Collectively, for one embodiment, these features sets provide the application data firewalls 149 for one embodiment. The following discusses each software feature set and then shows how the three sets work together to insure application and data isolation on the integrated circuit card 10.
  • An access control list is associated with every computational object (e.g., a data file or a communication channel) on the integrated circuit card 10 that is be protected, i.e., to which access is to be controlled.
  • An entry on an ACL (for a particular computational object) is in a data format referred to as an e-tuple: type : identity permissions
  • the type field indicates the type of the following identity (in the identity field), e.g., a user (e.g., "John Smith"), or a group.
  • the permissions field indicates a list of operations (e.g., read, append and update) that can be performed by the identity on the computational object.
  • the access is intercepted by the Card JVM 16 and passed to the card operating system 122, which determines if there is an ACL associated with the object. If there is an associated ACL, then the identity 190c associated with the running application 200 is matched on the ACL. If the identity is not found or if the identity is not permitted for the type of access that is being requested, then the access is denied. Otherwise, the access is allowed to proceed.
  • communication channel isolation is accomplished by including in the identity authentication process the exchange of a one-time session key 209 between the a card application 126z and the terminal application 136.
  • the key 209 is then used to encrypt subsequent traffic between the authenticating terminal application 136 and the authenticated card application 126z.
  • a rogue terminal application can neither "listen in” on an authenticated communication between the terminal 14 and the integrated circuit card 10, nor can the rogue terminal application "spoof" the card application into performing unauthorized operations on its behalf.
  • Encryption and decryption of card/terminal traffic can be handled either by the card operating system 122 or by the card application itself 126z.
  • the communication with the terminal 14 is being encrypted transparently to the application, and message traffic arrives decrypted in the data space of the application.
  • the card application 126z elects to perform encryption and decryption to provide an extra layer of security since the application could encrypt data as soon as it was created and would decrypt data only when it was about to be used. Otherwise, the data would remain encrypted with the session key 209.
  • the application firewall includes three mutually reinforcing software sets. Data files are protected by authenticated-identity access control lists. Application execution spaces are protected by the Card JVM 16. Communication channels are protected with one-time session encryption keys 209.
  • a microcontroller such as the processor 12
  • the microcontroller provides a small platform (i.e., a central processing unit, and a memory, both of which are located on a semiconductor substrate) for storing and executing high level programming languages.
  • Most existing devices and new designs that utilize a microcontroller could use this invention to provide the ability to program the microcontroller using a high level language, and application of this invention to such devices is specifically included.
  • application includes any program, such as Java applications, Java applets, Java aglets, Java servlets, Java commlets, Java components, and other non- Java programs that can result in class files as described below.
  • Class files may have a source other than Java program files.
  • Several programming languages other than Java also have compilers or assemblers for generating class files from their respective source files.
  • the programming language Eiffel can be used to generate class files using Pirmin Kalberer's "J-Eiffel”, an Eiffel compiler with JVM byte code generation (web site: http://www.spin.ch/ ⁇ kalberer/jive/index.htm).
  • An Ada 95 to Java byte code translator is described in the following reference (incorporated herein by reference) : Taft, S. Tucker, "Programming the Internet in Ada 95", proceedings of Ada Europe '96, 1996.
  • Jasmin is a Java byte code assembler that can be used to generate class files, as described in the following reference (incorporated herein by reference) : Meyer, Jon and Troy Downing, "Java Virtual Machine", O'Reilly, 1997. Regardless of the source of the class files, the above description applies to languages other than Java to generate codes to be interpreted.
  • Fig. 21 shows an integrated circuit card, or smart card, which includes a microcontroller 210 that is mounted to a plastic card 212.
  • the plastic card 212 has approximately the same form factor as a typical credit card.
  • the communicator 12a can use a contact pad 214 to establish a communication channel, or the communicator 12a can use a wireless communication system.
  • a microcontroller 210 is mounted into a mobile or fixed telephone 220, effectively adding smart card capabilities to the telephone, as shown in Fig. 22.
  • the microcontroller 210 is mounted on a module (such as a Subscriber Identity Module (SIM) ) , for insertion and removal from the telephone 220.
  • SIM Subscriber Identity Module
  • a microcontroller 210 is added to a key ring 230 as shown in Fig. 23. This can be used to secure access to an automobile that is equipped to recognize the identity associated with the microcontroller 210 on the key ring 230.
  • Jewelry such as a watch or ring 240 can also house a microcontroller 210 in an ergonomic manner, as shown in Fig. 24.
  • Such embodiments typically use a wireless communication system for establishing a communication channel, and are a convenient way to implement access control with a minimum of hassle to the user.
  • Fig. 25 illustrates a microcontroller 210 mounted in an electrical subsystem 252 of an automobile 254.
  • the microcontroller is used for a variety of purposes, such as to controlling access to the automobile, (e.g. checking identity or sobriety before enabling the ignition system of the automobile) , paying tolls via wireless communication, or interfacing with a global positioning system (GPS) to track the location of the automobile, to name a few.
  • GPS global positioning system
  • the card class file is a compressed form of the original class file(s).
  • the card class file contains only the semantic information required to interpret Java programs from the original class files.
  • the indirect references in the original class file are replaced with direct references resulting in a compact representation.
  • the card class file format is based on the following principles:
  • the card class file format should remain as close to the standard class file format as possible.
  • the Java byte codes in the class file remain unaltered. Not altering the byte codes ensures that the structural and static constraints on them remain verifiably intact.
  • the card class file format must be compact in order to accommodate smart card technology. It must meet the constraints of today's technology while not losing sight of tomorrow's innovations.
  • the constant pool is optimized to contain only 16-bit identifiers and, where possible, indirection is replaced by a direct reference. Attributes in the original class file are eliminated or regrouped.
  • the Java Card class File Format This section describes the Java Card class file format. Each card class file contains one or many Java types, where a type may be a class or an interface. A card class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively. Multi-byte data items are always stored in big-endian order, where the high bytes come first. In Java, this format is supported by interfaces java.io.Datalnput and java.io.DataOutput and classes such as java.io.DatalnputStream and java.io.DataOutputStream.
  • the types u , u2, and u4 represent an unsigned one-, two-, or four-byte quantity, respectively. In Java, these types may be read by methods such as readUnsignedByte, readUnsignedShort, and readint of the interface java.io.Datalnput.
  • the card class file format is presented using pseudo-structures written in a C-like structure notation. To avoid confusion with the fields of Java Card Virtual Machine classes and class instances, the contents of the structures describing the card class file format are referred to as items. Unlike the fields of a C structure, successive items are stored in the card class file sequentially, without padding or alignment.
  • Variable-sized tables consisting of variable-sized items, are used in several class file structures. Although we will use C-like array syntax to refer to table items, the fact that tables are streams of varying-sized structures means that it is not possible to directly translate a table index into a byte offset into the table. Where we refer to a data structure as an array, it is literally an array. In order to distinguish between the card class file structure and the standard class file structure, we add capitalization; for example, we rename fieldjnfo in the original class file to Fieldlnfo in the card class file. Card Class File
  • a card class file contains a single CardClassFile structure: CardClassFile ⁇ u1 major_version; u1 minor_version; u2 namejndex; u2 cons t_size; u2 max_class;
  • the values of the minor_version and major_version items are the minor and major version numbers of the off-card Java Card Virtual Machine that produced this card class file.
  • An implementation of the Java Card Virtual Machine normally supports card class files having a given major version number and minor version numbers 0 through some particular minor_version.
  • namejndex item must represent a valid Java class name.
  • the Java class name represented by namejndex must be exactly the same Java class name that corresponds to the main application that is to run in the card.
  • a card class file contains several classes or interfaces that constitute the application that runs in the card. Since Java allows each class to contain a main method there must be a way to distinguish the class file containing the main method which corresponds to the card application. const_size
  • const_size gives the number of entries in the card class file constant pool.
  • a constant_pool index is considered valid if it is greater than or equal to zero and less than cons t_size.
  • the constant_pool is a table of variable-length structures () representing various string constants, class names, field names, and other constants that are referred to within the
  • CardClassFile structure and its substructures.
  • the first entry in the card class file is constant_pool[0].
  • Each of the constant_pool table entries at indices 0 through cons t_size is a variable-length structure ().
  • the class is a table of max_class classes that constitute the application loaded onto the card. Constant Pool
  • Each item in the constant_pool table must begin with a 1-byte tag indicating the kind of cpjnfo entry.
  • the contents of the info array varies with the value of tag.
  • the valid tags and their values are the same as those specified in the Red book.
  • Each tag byte must be followed by two or more bytes giving information about the specific constant.
  • the format of the additional information varies with the tag value.
  • CONSTANT_Class CONSTANT_Class
  • CONSTANT_FieldRef CONSTANTj ethodRef
  • CONSTANTJnterfaceRef Support for other tags be added as they are included in the specification.
  • CONSTANT_Class The CONSTAN.T_Class_info structure is used to represent a class or an interface:
  • the tag item has the value CONSTANT_Class (7). namejndex
  • namejndex item must represent a valid Java class name.
  • the Java class name represented by namejndex must be exactly the same Java class name that is described by the corresponding CONSTANT_Class entry in the constant_pool of the original class file.
  • CONSTANT_Fieldref CONSTANT_Methodref
  • CONSTANTJnterfaceMethodref Fields, methods, and interface methods are represented by similar structures: CONSTANT_Fieldreflnfo ⁇ u1 tag; u2 classjndex; u2 name_sig_index;
  • the tag item of a CONSTANT_Fieldreflnfo structure has the value CONSTANT_Fieldref (9).
  • the tag item of a CONSTANTjVlethodreflnfo structure has the value CONSTANTj ethodref (10).
  • the tag item of a CONSTANTJnterfaceMethodreflnfo structure has the value CONSTANTJnterfaceMethodref (11). classsjndex
  • classjndex The value of the classjndex item must represent a valid Java class or interface name.
  • the name represented by classjndex must be exactly the same name that is described by the corresponding CONSTANT_Class_info entry in the constant_pool of the original class file. name_sig ndex
  • name_sig_index The value of the name_sig_index item must represent a valid Java name and type.
  • name_sig_index The name and type represented by name_sig_index must be exactly the same name and type described by the CONSTANT_NameAndType_info entry in the constant_pool structure of the original class file.
  • Classlnfo Each class is described by a fixed-length Classlnfo structure.
  • the format of this structure is: Classlnfo ⁇ u2 namejndex; u1 max_field; ui max sfield; u1 maxjnethod; u1 maxjnterface; u2 superclass; u2 access_flags;
  • namejndex item must represent a valid Java class name.
  • the Java class name represented by namejndex must be exactly the same Java class name that is described in the corresponding ClassFile structure of the original class file.
  • max_field item gives the number of Fieldlnfo () structures in the field table that represent the instance variables, declared by this class or interface type. This value refers to the number of non-static the fields in the card class file. If the class represents an interface the value of max_field is 0. max_sf ⁇ eld
  • max_sfield item gives the number of Fieldlnfo structures in the field table that represent the class variables, declared by this class or interface type. This value refers to the number of static the fields in the card class file.
  • the value of the superclass item must represent a valid Java class name.
  • the Java class name represented by superclass must be exactly the same Java class name that is described in the corresponding ClassFile structure of the original class file.
  • the value of the access_flags item is a mask of modifiers used with class and interface declarations.
  • the access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding ClassFile structure of the original class file. fieldQ
  • Each value in the field table must be a fixed-length Fieldlnfo () structure giving a complete description of a field in the class or interface type.
  • the field table includes only those fields that are declared by this class or interface. It does not include items representing fields that are inherited from superclasses or superinterfaces. interface!]
  • Each value in the interface array must represent a valid interface name.
  • the interface name represented by each entry must be exactly the same interface name that is described in the corresponding interface array of the original class file.
  • Each value in the method table must be a variabie-length Methodlnfo () structure giving a complete description of and Java Virtual Machine code for a method in the class or interface.
  • the Methodlnfo structures represent all methods, both instance methods and, for classes, class (static) methods, declared by this class or interface type.
  • the method table only includes those methods that are explicitly declared by this class. Interfaces have only the single method ⁇ clinit>, the interface initialization method.
  • the methods table does not include items representing methods that are inherited from superclasses or superinterfaces. Fields
  • Each field is described by a fixed-length fieldj ' nfo structure.
  • the format of this structure is Fieldlnfo ⁇ u2 namejndex; u2 signaturejndex; u2 access_flags;
  • the items of the Fieldlnfo structure are as follows: name index
  • the value of the namejndex item must represent a valid Java field name.
  • the Java field name represented by namejndex must be exactly the same Java field name that is described in the corresponding fieldjnfo structure of the original class file. signaturejndex
  • the value of the signaturejndex item must represent a valid Java field descriptor.
  • Java field descriptor represented by signature index must be exactly the same Java field descriptor that is described in the corresponding fieldjnfo structure of the original class file. access ⁇ lags
  • the value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a field.
  • the access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding fieldjnfo structure of the original class file.
  • the Methodlnfo structure is a variable-length structure that contains the Java Virtual Machine instructions and auxiliary information for a single Java method, instance initialization method, or class or interface initialization method.
  • the structure has the following format:
  • namejndex item must represent either one of the special intemal method names, either ⁇ init> or ⁇ clinit>, or a valid Java method name.
  • the Java method name represented by namejndex must be exactly the same Java method name that is described in the corresponding method j ' nfo structure of the original class file. signaturejndex
  • the value of the signaturejndex item must represent a valid Java method descriptor.
  • the value of the maxjocals item gives the number of local variables used by this method, excluding the parameters passed to the method on invocation.
  • the index of the first local variable is 0.
  • the greatest local variable index for a one-word value is max_Iocals-1.
  • max_stack item gives the maximum number of words on the operand stack at any point during execution of this method. access_flags
  • the value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a method or instance initialization method. .
  • the access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding method j ' nfo structure of the original class file. codejength
  • codejength item gives the number of bytes in the code array for this method.
  • the value of codejength must be greater than zero; the code array must not be empty.
  • the code array gives the actual bytes of Java Virtual Machine code that implement the method.
  • the code array is read into memory on a byte addressable machine, if the first byte of the array is aligned on a 4-byte boundary, the tableswitch and lookupswitch 32-bit offsets will be 4-byte aligned; refer to the descriptions of those instructions for more information on the consequences of code array alignment.
  • Each entry in the einfo array describes one exception handler in the code array.
  • Each einfo entry contains the following items: startjpc, endjpc
  • the values of the two items start_pc and end_pc indicate the ranges in the code array at which the exception handler is active.
  • startjpc must be a valid index into the code array of the opcode of an instruction.
  • endjpc either must be a valid index into the code array of the opcode of an instruction, or must be equal to codejength, the length of the code array.
  • start_pc must be less than the value of endjpc.
  • startjpc is inclusive and endjpc is exclusive; that is, the exception handler must be active while the program counter is within the interval [startjpc, endjpc]. handlerjpc
  • the value of the handlerjpc item indicates the start of the exception handler.
  • the value of the item must be a valid index into the code array, must be the index of the opcode of an instruction, and must be less than the value of the codejength item. catch_type
  • catch Jype item If the value of the catch Jype item is nonzero, it must represent a valid Java class type.
  • the Java class type represented by catch ype must be exactly the same as the Java class type that is described by the catchjype in the corresponding methodjnfo structure of the original class file.
  • This class must be the class Throwable or one of its subclasses.
  • the exception handler will be called only if the thrown exception is an instance of the given class or one of its subclasses.
  • Attributes used in the original class file are either eliminated or regrouped for compaction.
  • the predefined attributes SourceFile, ConstantValue, Exceptions, LineNumberTable, and Local-VariableTable may be eliminated without sacrificing any information required for Java byte code interpretation.
  • the predefined attribute Code which contains all the byte codes for a particular method are moved in the corresponding Methodlnfo structure.
  • Java Card Virtual Machine code for a method, instance initialization method, or class or interface initialization method is stored in the array code of the Methodlnfo structure of a card class file. Both the static and the structural constraints on this code array are the same as those described in the Red book.
  • the per-card class file constant pool is limited to 65535 entries by the 16-bit cons t_size field of the CardClassFile structure (). This acts as an internal limit on the total complexity of a single card class file. This count also includes the entries corresponding to the constant pool of the class hierarchy available to the application in the card.
  • the amount of code per method is limited to 65535 bytes by the sizes of the indices in the Methodlnfo structure.
  • the number of local variables in a method is limited to 255 by the size of the maxjocal item of the Methodlnfo structure ().
  • the number of fields of a class is limited to 510 by the size of the max_field and the max_sfield items of the Classlnfo structure ().
  • the number of methods of a class is limited to 255 by the size of the maxjriethod item of the Classlnfo structure ().
  • the size of an operand stack is limited to 255 words by the max_stack field of the
  • HelloSmartCard.java When compiled it generates a class file HelloSmartCard. class.
  • This class file has embedded in it strings that represent the class name, methods and type information.
  • Card Class File Converter On the basis of the String-ID INMap described above Card Class File Converter generates a card class file that replaces the strings present in the class file with IDs allocated by Card Class File Converter.
  • Table 1 lists the strings found in the constant pool of HelloSmartCard. class with their respective Card Class File Converter assigned IDs. Note that some strings (like "java/lang/Object”) have a pre-assigned value (F002) and some strings (like "()V”) get a new value (4004).
  • codeinfo is a table that keeps track of the valid Java bytecodes and their
  • switch code[pc]
  • bRetumStatus _OS.VerifyKey(pbuffer[3], dbuffer, pbuffer[4]); break;
  • static native byte SelectFile (short filejd); static native byte SelectParent 0; static native byte SelectCD 0; static native byte SelectRoot 0;
  • static native byte ReadRecord (byte record_data[], byte recordjib, byte offset, byte length); static native byte WriteRecord (byte buffer[], byte recordjib, byte offset, byte length);
  • Each bytecode is assigned a 5 bit type associated with it. This is used to group the codes into similarly behaving sets. In general this behaviour reflects how the types of byte codes operate on the stack, but types 0, 13, 14, and 15 reflect specific kinds of instructions as denoted in the comments section.

Abstract

An integrated circuit card is used with a terminal. The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal.

Description

USING A HIGH LEVEL PROGRAMMING LANGUAGE WITH A MICROCONTROLLER A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
Under 35 U.S.C. § 119(e), this application claims benefit of prior U.S. provisional application Serial No. 60/029,057, filed October 25, 1996.
Background of the Invention
This invention relates in general to the field of programming, and more particularly to using a high level programming language with a smart card or a microcontroller. Software applications written in the Java high-level programming language have been so designed that an application written in Java can be run on many different computer brands or computer platforms without change. This is accomplished by the following procedure. When a Java application is written, it is compiled into "Class" files containing byte codes that are instructions for a hypothetical computer called a Java Virtual Machine. An implementation of this virtual machine is written for each platform that is supported. When a user wishes to run a particular Java application on a selected platform, the class files compiled from the desired application is loaded onto the selected platform. The Java virtual machine for the selected platform is run, and interprets the byte codes in the class file, thus effectively running the Java application. Java is described in the following references which are hereby incorporated by reference: (1) Arnold, Ken, and James Gosling, "The Java Programming Language, " Addison-Wesley, 1996; (2) James Gosling, Bill Joy, and Guy Steele, "The Java Language Specification, " Sun Microsystems, 1996, (web site: http://java.sun.com/doc/language_specification) ; (3) James Gosling and Henry McGilton, "The Java Language Environment: A White Paper," Sun Microsystems, 1995 (web site: http://java.sun.com/doc/language_environment/); and (4) Tim Lindholm and Frank Yellin, "The Java Virtual Machine Specification," Addison-Wesley, 1997. These texts among many others describe how to program using Java. In order for a Java application to run on a specific platform, a Java virtual machine implementation must be written that will run within the constraints of the platform, and a mechanism must be provided for loading the desired Java application on the platform, again keeping within the constraints of this platform. Conventional platforms that support Java are typically microprocessor-based computers, with access to relatively large amounts of memory and hard disk storage space. Such microprocessor implementations frequently are used in desktop and personal computers. However, there are no conventional Java implementations on microcontrollers, as would typically be used in a smart card.
Microcontrollers differ from microprocessors in many ways. For example, a microprocessor typically has a central processing unit that requires certain external components (e.g., memory, input controls and output controls) to function properly. A typical microprocessor can access from a megabyte to a gigabyte of memory, and is capable of processing 16, 32, or 64 bits of information or more with a single instruction. In contrast to the microprocessor, a microcontroller includes a central processing unit, memory and other functional elements, all on a single semiconductor substrate, or integrated circuit (e.g., a "chip"). As compared to the relatively large external memory accessed by the microprocessor, the typical microcontroller accesses a much smaller memory. A typical microcontroller can access one to sixty- four kilobytes of built-in memory, with sixteen kilobytes being very common .
There are generally three different types of memory used: random access memory (RAM) , read only memory (ROM) , and electrically erasable programmable read only memory (EEPROM) . In a microcontroller, the amount of each kind of memory available is constrained by the amount of space on the integrated circuit used for each kind of memory. Typically, RAM takes the most space, and is in shortest supply. ROM takes the least space, and is abundant. EEPROM is more abundant than RAM, but less than ROM.
Each kind of memory is suitable for different purposes. Although ROM is the least expensive, it is suitable only for data that is unchanging, such as operating system code. EEPROM is useful for storing data that must be retained when power is removed, but is extremely slow to write. RAM can be written and read at high speed, but is expensive and data in RAM is lost when power is removed. A microprocessor system typically has relatively little ROM and EEPROM, and has 1 to 128 megabytes of RAM, since it is not constrained by what will fit on a single integrated circuit device, and often has access to an external disk memory system that serves as a large writable, non-volatile storage area at a lower cost that EEPROM. However, a microcontroller typically has a small RAM of 0.1 to 2.0 K, 2K to 8K of EEPROM, and 8K - 56K of ROM.
Due to the small number of external components required and their small size, microcontrollers frequently are used in integrated circuit cards, such as smart cards . Such smart cards come in a variety of forms, including contact-based cards, which must be inserted into a reader to be used, and contactless cards, which need not be inserted. In fact, microcontrollers with contactless communication are often embedded into specialized forms, such as watches and rings, effectively integrating the functionality of a smart card in an ergonomically attractive manner. Because of the constrained environment, applications for smart cards are typically written in a low level programming language (e.g., assembly language) to conserve memory.
The integrated circuit card is a secure, robust, tamper-resistant and portable device for storing data. The integrated circuit card is the most personal of personal computers because of its small size and because of the hardware and software data security features unique to the integrated circuit card. The primary task of the integrated circuit card and the microcontroller on the card is to protect the data stored on the card. Consequently, since its invention in 1974, integrated circuit card technology has been closely guarded on these same security grounds. The cards were first used by French banks as debit cards. In this application, before a financial transaction based on the card is authorized, the card user must demonstrate knowledge of a 4 -digit personal identification number (PIN) stored in the card in addition to being in possession of the card. Any information that might contribute to discovering the PIN number on a lost or stolen card was blocked from public distribution. In fact, since nobody could tell what information might be useful in this regard, virtually all information about integrated circuit cards was withheld.
Due to the concern for security, applications written for integrated circuit cards have unique properties. For example, each application typically is identified with a particular owner or identity. Because applications typically are written in a low-level programming language, such as assembly language, the applications are written for a particular type of microcontroller. Due to the nature of low level programming languages, unauthorized applications may access data on the integrated circuit card. Programs written for a integrated circuit card are identified with a particular identity so that if two identities want to perform the same programming function there must be two copies of some portions of the application on the microcontroller of the integrated circuit card.
Integrated circuit card systems have historically been closed systems. An integrated circuit card contained a dedicated application that was handcrafted to work with a specific terminal application. Security checking when an integrated circuit card was used consisted primarily of making sure that the card application and the terminal application were a matched pair and that the data on the card was valid.
As the popularity of integrated circuit cards grew, it became clear that integrated circuit card users would be averse to carrying a different integrated circuit card for each integrated circuit card application. Therefore, multiple cooperating applications began to be provided on single provider integrated circuit cards. Thus, for example, an automated teller machine (ATM) access card and a debit card may coexist on a single integrated circuit card platform. Nevertheless, this was still a closed system since all the applications in the terminal and the card were built by one provider having explicit knowledge of the other providers .
The paucity of information about integrated circuit cards -- particularly information about how to communicate with them and how to program them -- has impeded the general application of the integrated circuit card. However, the advent of public digital networking (e.g., the Internet and the World Wide Web) has opened new domains of application for integrated circuit cards. In particular, this has lead to a need to load new applications on the card that do not have explicit knowledge of the other providers, but without the possibility of compromising the security of the card. However, typically, this is not practical with conventional cards that are programmed using low level languages.
Summary of the Invention In general, in one aspect, the invention features an integrated circuit card for use with a terminal . The integrated circuit card includes a memory that stores an interpreter and an application that has a high level programming language format. A processor of the card is configured to use the interpreter to interpret the application for execution and to use a communicator of the card to communicate with the terminal . Among the advantages of the invention are one or more of the following. New applications may be downloaded to a smart card without compromising the security of the smart card. These applications may be provided by different companies loaded at different times using different terminals. Security is not comprised since the applications are protected against unauthorized access of any application code or data by the security features provided by the Java virtual machine. Smart card applications can be created in high level languages such as Java and Eiffel, using powerful mainstream program development tools. New applications can be quickly prototyped and downloaded to a smart card in a matter of hours without resorting to soft masks. Embedded systems using microcontrollers can also gain many of these advantages for downloading new applications, high level program development, and rapid prototyping by making use of this invention.
Implementations of the invention may include one or more of the following. The high level programming language format of the application may have a class file format and may have a Java programming language format . The processor may be a microcontroller. At least a portion of the memory may be located in the processor. The application may have been processed from a second application that has a string of characters, and the string of characters may be represented in the first application by an identifier (e.g., an integer) .
The processor may be also configured to receive a request from a requester (e.g., a processor or a terminal) to access an element (e.g., an application stored in the memory, data stored in the memory or the communicator) of the card, after receipt of the request, interact with the requester to authenticate an identity of the requester, and based on the identity, selectively grant access to the element.
The memory may also store an access control list for the element. The access control list furnishes an indication of types of access to be granted to the identity, and based on the access control list, the processor selectively grants specific types of access (e.g., reading data, writing data, appending data, creating data, deleting data or executing an application) to the requester. The application may be one of a several applications stored in the memory. The processor may be further configured to receive a request from a requester to access one of the plurality of applications; after receipt of the request, determine whether said one of the plurality of applications complies with a predetermined set of rules; and based on the determination, selectively grant access to the requester to said one of the plurality of applications. The predetermined rules provide a guide for determining whether said one of the plurality of applications accesses a predetermined region of the memory. The processor may be further configured to authenticate an identity of the requester and grant access to said one of the plurality of applications based on the identity. The processor may be also configured to interact with the terminal via the communicator to authenticate an identity; determine if the identity has been authenticated; and based on the determination, selectively allow communication between the terminal and the integrated circuit card.
The communicator and the terminal may communicate via communication channels. The processor may also be configured to assign one of the communication channels to the identity when the processor allows the communication between the terminal and the integrated circuit card.
The processor may also be configured to assign a session key to the assigned communication channel and use the session key when the processor and the terminal communicate via the assigned communication channel. The terminal may have a card reader, and the communicator may include a contact for communicating with the card reader. The terminal may have a wireless communication device, and the communictor may include a wireless transceiver for communicating with the wireless communication device. The terminal may have a wireless communication device, and the communicator may include a wireless transmitter for communicating with the wireless communication device. In general, in another aspect, the invention features a method for use with an integrated circuit card and a terminal . The method includes storing an interpreter and at least one application having a high level programming language format in a memory of the integrated circuit card. A processor of the integrated circuit card uses the interpreter to interpret the at least one application for execution, and the processor uses a communicator of the card when communicating between the processor and the terminal . In general, in another aspect, the invention features a smart card. The smart card includes a memory that stores a Java interpreter and a processor that is configured to use the interpreter to interpret a Java application for execution. In general, in another aspect, the invention features a microcontroller that has a semiconductor substrate and a memory located in the substrate. A programming language interpreter is stored in the memory and is configured to implement security checks. A central processing unit is located in the substrate and is coupled to the memory.
Implementations of the invention may include one or more of the following. The interpreter may be a Java byte code interpreter. The security checks may include establishing firewalls and may include enforcing a sandbox security model .
In general, in another aspect, the invention features a smart card that has a programming language interpreter stored in a memory of the card. The interpreter is configured to implement security check. A central processing unit of the card is coupled to the memory .
In general, in another aspect, the invention features an integrated circuit card that is used with a terminal . The card includes a communicator and a memory that stores an interpreter and first instructions of a first application. The first instructions have been converted from second instructions of a second application. The integrated circuit card includes a processor that is coupled to the memory and is configured to use the interpreter to execute the first instructions and to communicate with the terminal via the communicator . Implementations of the invention may include one or more of the following. The first and/or second applications may have class file format (s) . The first and/or second applications may include byte codes, such as Java byte codes. The first instructions may be generalized or renumbered versions of the second instructions. The second instructions may include constant references, and the first instructions may include constants that replace the constant references of the second instructions. The second instructions may include references, and the references may shift location during the conversion of the second instructions to the first instructions. The first instructions may be relinked to the references after the shifting. The first instructions may include byte codes for a first type of virtual machine, and the second instructions may include byte codes for a second type of virtual machine. The first type is different from the second type.
In general, in another aspect, the invention features a method for use with an integrated circuit card. The method includes converting second instructions of a second application to first instructions of a first application; storing the first instructions in a memory of the integrated circuit card; and using an interpreter of the integrated circuit card to execute the first instructions.
In general, in another aspect, the invention features an integrated circuit for use with a terminal . The integrated circuit card has a communicator that is configured to communicate with the terminal and a memory that stores a first application that has been processed from a second application having a string of characters. The string of characters are represented in the first application by an identifier. The integrated circuit card includes a processor that is coupled to the memory. The processor is configured to use the interpreter to interpret the first application for execution and to use the communicator to communicate with the terminal .
In general, in another aspect, the invention features a method for use with an integrated circuit card and a terminal. The method includes processing a second application to create a first application. The second application has a string of characters. The string of characters is represented by an identifier in the second application. An interpreter and the first application are stored in a memory of the integrated circuit card. A processor uses an interpreter to interpret the first application for execution.
In general, in another aspect, the invention features a microcontroller that includes a memory which stores an application and an interpreter. The application has a class file format. A processor of the microcontroller is coupled to the memory and is configured to use the interpreter to interpret the application for execution. In implementations of the invention, the microcontroller may also include a communicator that is configured to communicate with a terminal .
In general, in another aspect, the invention features a method for use with an integrated circuit card. The method includes storing a first application in a memory of the integrated circuit card, storing a second application in the memory of the integrated circuit card, and creating a firewall that isolates the first and second applications so that the second application cannot access either the first application or data associated with the first application.
In general, in another aspect, the invention features an integrated circuit card for use with a terminal . The integrated circuit card includes a communicator that is configured to communicate with the terminal, a memory and a processor. The memory stores applications, and each application has a high level programming language format. The memory also stores an interpreter. The processor is coupled to the memory and is configured to: a.) use the interpreter to interpret the applications for execution, b.) use the interpreter to create a firewall to isolate the applications from each other, and c.) use the communicator to communicate with the terminal . Other advantages and features will become apparent from the following description and from the claims.
Brief Description of the Drawing Fig. 1 is a block diagram of an integrated card system.
Fig. 2 is a flow diagram illustrating the preparation of Java applications to be downloaded to an integrated circuit card.
Fig. 3 is a block diagram of the files used and generated by the card class file converter.
Fig. 4 is a block diagram illustrating the transformation of application class file(s) into a card class file.
Fig. 5 is a flow diagram illustrating the working of the class file converter.
Fig. 6 is a flow diagram illustrating the modification of the byte codes. Fig. 7 is a block diagram illustrating the transformation of specific byte codes into general byte codes .
Fig. 8 is a block diagram illustrating the replacement of constant references with constants. Fig. 9 is a block diagram illustrating the replacement of references with their updated values.
Fig. 10 is a block diagram illustrating renumbering of original byte codes.
Fig. 11 is a block diagram illustrating translation of original byte codes for a different virtual machine architecture.
Fig 12 is a block diagram illustrating loading applications into an integrated circuit card.
Fig. 13 is a block diagram illustrating executing applications in an integrated circuit card.
Fig. 14 is a schematic diagram illustrating memory organization for ROM, RAM and EEPROM.
Fig. 15 is a flow diagram illustrating the overall architecture of the Card Java virtual machine. Fig. 16 is a flow diagram illustrating method execution in the Card Java virtual machine with the security checks.
Fig. 17 is a flow diagram illustrating byte code execution in the Card Java virtual machine.
Fig. 18 is a flow diagram illustrating method execution in the Card Java virtual machine without the security checks .
Fig. 19 is a block diagram illustrating the association between card applications and identities.
Fig. 20 is a block diagram illustrating the access rights of a specific running application.
Fig. 21 is a perspective view of a microcontroller on a smart card. Fig. 22 is a perspective view of a microcontroller on a telephone.
Fig. 23 is a perspective view of a microcontroller on a key rin .
Fig. 24 is a perspective view of a microcontroller on a ring.
Fig. 25 is a perspective view of a microcontroller on a circuit card of an automobile.
Detailed Description of the Preferred Embodiments Referring to Fig. 1, an integrated circuit card 10 (e.g., a smart card) is constructed to provide a high level, Java-based, multiple application programming and execution environment. The integrated circuit card 10 has a communicator 12a that is configured to communicate with a terminal communicator 12b of a terminal 14. In some embodiments, the integrated circuit card 10 is a smart card with an 8 bit microcontroller, 512 bytes of RAM, 4K bytes of EEPROM, and 20K of ROM; the terminal communicator 12b is a conventional contact smart card reader; and the terminal 14 is a conventional personal computer running the Windows NT operating system supporting the personal computer smart card (PC/SC) standard and providing Java development support .
In some embodiments, the microcontroller, memory and communicator are embedded in a plastic card that has substantially the same dimensions as a typical credit card. In other embodiments, the microcontroller, memory and communicator are mounted within bases other than a plastic card, such as jewelry (e.g., watches, rings or bracelets) , automotive equipment, telecommunication equipment (e.g., subscriber identity module (SIM) cards), security devices (e.g., cryptographic modules) and appliances .
The terminal 14 prepares and downloads Java applications to the integrated circuit card 10 using the terminal communicator 12b. The terminal communicator 12b is a communications device capable of establishing a communications channel between the integrated circuit card 10 and the terminal 14. Some communication options include contact card readers, wireless communications via radio frequency or infrared techniques, serial communication protocols, packet communication protocols, ISO 7816 communication protocol, to name a few. The terminal 14 can also interact with applications running in the integrated circuit card 10. In some cases, different terminals may be used for these purposes. For example, one kind of terminal may be used to prepare applications, different terminals could be used to download the applications, and yet other terminals could be used to run the various applications. Terminals can be automated teller machines (ATM)s, point - of-sale terminals, door security systems, toll payment systems, access control systems, or any other system that communicates with an integrated circuit card or microcontroller. The integrated circuit card 10 contains a card Java virtual machine (Card JVM) 16, which is used to interpret applications which are contained on the card 10. Referring to Fig. 2, the Java application 20 includes three Java source code files A.java 20a, B.java 20b, and C.java 20c. These source code files are prepared and compiled in a Java application development environment 22. When the Java application 20 is compiled by the development environment 22, application class files 24 are produced, with these class files A. class 24a, B. class 24b, and C. class 24c corresponding to their respective class Java source code 20a, 20b, and 20c. The application class files 24 follow the standard class file format as documented in chapter 4 of the Java virtual machine specification by Tim Lindholm and Frank Yellin, "The Java Virtual Machine Specification, " Addison-Wesley, 1996. These application class files 24 are fed into the card class file converter 26, which consolidates and compresses the files, producing a single card class file 27. The card class file 27 is loaded to the integrated circuit card 10 using a conventional card loader 28.
Referring to Fig. 3, the card class file converter 26 is a class file postprocessor that processes a set of class files 24 that are encoded in the standard Java class file format, optionally using a string to ID input map file 30 to produce a Java card class file 27 in a card class file format. One such card class file format is described in Appendix A which is hereby incorporated by reference. In addition, in some embodiments, the card class file converter 26 produces a string to ID output map file 32 that is used as input for a subsequent execution of the card class file converter.
In some embodiments, in order for the string to ID mapping to be consistent with a previously generated card class file (in the case where multiple class files reference the same strings) , the card class file converter 26 can accept previously defined string to ID mappings from a string to ID input map file 30. In the absence of such a file, the IDs are generated by the card class file converter 26. Appendix B, which is hereby incorporated by reference, describes one possible way of implementing and producing the string to ID input map file 30 and string to ID output map file 32 and illustrates this mapping via an example.
Referring to Fig. 4, a typical application class file 24a includes class file information 41; a class constant pool 42; class, fields created, interfaces referenced, and method information 43; and various attribute information 44, as detailed in aforementioned Java Virtual Machine Specification. Note that much of the attribute information 44 is not needed for this embodiment and is eliminated 45 by the card class file converter 26. Eliminated attributes include SourceFile, ConstantValue, Exceptions, LineNumberTable,
LocalVariableTable, and any optional vendor attributes. The typical card class file 27 as described in Appendix A is derived from the application class files 24 in the following manner. The card class file information 46 is derived from the aggregate class file information 41 of all application class files 24a, 24b, and 24c. The card class file constant pool 47 is derived from the aggregate class constant pool 42 of all application class files 24a, 24b, and 24c. The card class, fields created, interfaces referenced, and method information 48 is derived from the aggregate class, fields created, interfaces referenced, and method information 43 of all application class files 24a, 24b, and 24c. The card attribute information 49 in this embodiment is derived from only the code attribute of the aggregate attribute information 44 of all application class files 24a, 24b, and 24c.
To avoid dynamic linking in the card, all the information that is distributed across several Java class file 24a, 24b, and 24c that form the application 24, are coalesced into one card class file 27 by the process shown in the flowchart in Fig. 5. The first class file to be processed is selected 51a. The constant pool 42 is compacted 51b in the following manner. All objects, classes, fields, methods referenced in a Java class file 24a are identified by using strings in the constant pool 42 of the class file 24a. The card class file converter 26 compacts the constant pool 42 found in the Java class file 24a into an optimized version. This compaction is achieved by mapping all the strings found in the class file constant pool 42 into integers (the size of which is microcontroller architecture dependent) . These integers are also referred to as IDs. Each ID uniquely identifies a particular object, class, field or method in the application 20. Therefore, the card class file converter 26 replaces the strings in the Java class file constant pool 42 with its corresponding unique ID. Appendix B shows an example application HelloSmartCard. java, with a table below illustrating the IDs corresponding to the strings found in the constant pool of the class file for this application. The IDs used for this example are 16- bit unsigned integers.
Next, the card class file converter 26 checks for unsupported features 51c in the Code attribute of the input Java class file 24a. The Card JVM 16 only supports a subset of the full Java byte codes as described in Appendix C, which is hereby incorporated by reference. Hence, the card class file converter 26 checks for unsupported byte codes in the Code attribute of the Java class file 24a. If any unsupported byte codes are found 52, the card class file converter flags an error and stops conversion 53. The program code fragment marked "A" in APPENDIX D shows how these spurious byte codes are apprehended. Another level of checking can be performed by requiring the standard Java development environment 22 to compile the application 20 with a λ-g' flag. Based on the aforementioned Java virtual machine specification, this option requires the Java compiler to place information about the variables used in a Java application 20 in the LocalVariableTable attribute of the class file 24a. The card class file converter 26 uses this information to check if the Java class file 24a references data types not supported by the Java card.
Next, the card class file converter 26 discards all the unnecessary parts 51c of the Java class file 24a not required for interpretation. A Java class file 24a stores information pertaining to the byte codes in the class file in the Attributes section 44 of the Java class file. Attributes that are not required for interpretation by the card JVM 16, such as SourceFile, ConstantValue, Exceptions, LineNumberTable, and LocalVariableTable may be safely discarded 45. The only attribute that is retained is the Code attribute. The Code attribute contains the byte codes that correspond to the methods in the Java class file 24a.
Modifying the byte codes 54 involves examining the Code attribute information 44 for each method in the class file, and modifying the operands of byte codes that refer to entries in the Java class file constant pool 42 to reflect the entries in the card class file constant pool 47. In some embodiments, the byte codes are also modified, as described below.
Modifying the byte codes 54 involves five passes (with two optional passes) as described by the flowchart in Fig. 6. The original byte codes 60 are found in the Code attribute 44 of the Java class file 24a being processed. The first pass 61 records all the jumps and their destinations in the original byte codes. During later byte code translation, some single byte code may be translated to dual or triple bytes. Fig. 7 illustrates an example wherein byte code ILOAD_0 is replaced with two bytes, byte code ILOAD and argument 0. When this is done, the code size changes, requiring adjustment of any jump destinations which are affected. Therefore, before these transformations are made, the original byte codes 60 are analyzed for any jump byte codes and a note made of their position and current destination. The program code fragment marked "B" in Appendix D shows how these jumps are recorded. Appendix D is hereby incorporated by reference.
Once the jumps are recorded, if the optional byte code translation is not being performed 62, the card class file converter 26 may proceed to the third pass 64. Otherwise, the card class file converter converts specific byte codes into generic byte codes. Typically, the translated byte codes are not interpreted in the Card JVM 16 but are supported by converting the byte codes into equivalent byte codes that can be interpreted by the Card JVM 16 (see Fig. 7) . The byte codes 70 may be replaced with another semantically equivalent but different byte codes 72. This generally entails the translation of short single specific byte codes such as ILOAD_0 into their more general versions. For example, ILOAD_0 may be replaced by byte code ILOAD with an argument 0. This translation is done to reduce the number of byte codes translated by the Card JVM 16, consequently reducing the complexity and code space requirements for the Card JVM 16. The program code fragment marked "C" in Appendix D shows how these translations are made. Note that such translations increase the size of the resulting byte code and force the re-computation of any jumps which are affected.
In the third pass 64, the card class file converter rebuilds constant references via elimination of the strings used to denote these constants. Fig. 8 shows an example wherein the byte code LDC 80 referring to constant "18" found via an index in the Java class file 24a constant pool 42 may be translated into BIPUSH byte code 82. In this pass the card class file converter 26 modifies the operands to all the byte codes that refer to entries in the Java class file constant pool 42 to reflect their new location in the card class file constant pool 47. Fig. 9 shows an example wherein the argument to a byte code, INVOKESTATIC 90, refers to an entry in the Java class file constant pool 42 that is modified to reflect the new location of that entry in the card class file constant pool 47. The modified operand 94 shows this transformation. The program code fragment marked "D" in Appendix D shows how these modifications are made .
Once the constant references are relinked, if the optional byte code modification is not being performed, the card class file converter may proceed to the fifth and final pass 67. Otherwise, the card class file converter modifies the original byte codes into a different set of byte codes supported by the particular Card JVM 16 being used. One potential modification renumbers the original byte codes 60 into Card JVM 16 byte codes (see Fig. 10) . This renumbering causes the byte codes 100 in the original byte codes 60 to be modified into a renumbered byte codes 102. Byte code ILOAD recognized by value 21 may be renumbered to be recognized by value 50. This modification may be done for optimizing the type tests (also known in prior art as Pass 3 checks) in the Card JVM 16. The program code fragment marked "E" in Appendix D shows an implementation of this embodiment. This modification may be done in order to reduce the program space required by the Card JVM 16 to interpret the byte code. Essentially this modification regroups the byte codes into Card JVM 16 byte codes so that byte codes with similar operands, results are grouped together, and there are no gaps between Card JVM 16 byte codes. This allows the Card JVM 16 to efficiently check Card JVM 16 byte codes and validate types as it executes.
In some embodiments, the card class file converter modifies the original byte codes 60 into a different set of byte codes designed for a different virtual machine architecture, as shown in Fig. 11. The Java byte code ILOAD 112 intended for use on a word stack 114 may be replaced by Card JVM 16 byte code ILOAD_B 116 to be used on a byte stack 118. An element in a word stack 114 requires allocating 4 bytes of stack space, whereas an element in the byte stack 118 requires only one byte of stack space. Although this option may provide an increase in execution speed, it risks losing the security features available in the original byte codes.
Since the previous steps 63, 64 or 66 may have changed the size of the byte codes 60 the card class file converter 26 has to relink 67 any jumps which have been effected. Since the jumps were recorded in the first step 61 of the card class file converter 26, this adjustment is carried out by fixing the jump destinations to their appropriate values. The program code fragment marked "F" in Appendix D shows how these jumps are fixed. The card class file converter now has modified byte codes 68 that is equivalent to the original byte codes 60 ready for loading. The translation from the Java class file 24a to the card class file 27 is now complete. Referring back to Fig. 5, if more class files 24 remain to be processed 55 the previous steps 51a, 51b, 51c, 52 and 54 are repeated for each remaining class file. The card class file converter 26 gathers 56 the maps and modified byte codes for the classes 24 that have been processed, places them as an aggregate and generates 57 a card class file 27. If required, the card class file converter 26 generates a string to ID output map file 32, that contains a list of all the new IDs allocated for the strings encountered in the constant pool 42 of the Java class files 24 during the translation.
Referring to Fig. 12, the card loader 28 within the terminal 14 sends a card class file to the loading and execution control 120 within the integrated circuit card 10 using standard ISO 7816 commands. The loading and execution control 120 with a card operating system 122, which provides the necessary system resources, including support for a card file system 124, which can be used to store several card applications 126. Many conventional card loaders are written in low level languages, supported by the card operating system 122. In the preferred embodiment, the bootstrap loader is written in Java, and the integrated circuit card 10 includes a Java virtual machine to run this application. A Java implementation of the loading and execution control 120 is illustrated in Appendix E which is hereby incorporated by reference. The loading and execution control 120 receives the card class file 26 and produces a Java card application 126x stored in the card file system 126 in the EEPROM of the integrated circuit card 10. Multiple Java card applications 126x, 126y, and 126z can be stored in a single card in this manner. The loading and execution control 120 supports commands whereby the terminal 14 can select which Java card application to run immediately, or upon the next card reset .
Referring to Fig. 13, upon receiving a reset or an execution command from the loading and execution control 120, the Card Java Virtual Machine (Card JVM) 16 begins execution at a predetermined method (for example, main) of the selected class in the selected Java Card application 126z. The Card JVM 16 provides the Java card application 126z access to the underlying card operating system 122, which provides capabilities such as I/O,
EEPROM support, file systems, access control, and other system functions using native Java methods as illustrated in Appendix F which is hereby incorporated by reference.
The selected Java card application 126z communicates with an appropriate application in the terminal 14 using the communicator 12a to establish a communication channel to the terminal 14. Data from the communicator 12a to the terminal 14 passes through a communicator driver 132 in the terminal, which is specifically written to handle the communications protocol used by the communicator 12a. The data then passes to an integrated circuit card driver 134, which is specifically written to address the capabilities of the particular integrated circuit card 10 being used, and provides high level software services to the terminal application 136. In the preferred embodiment, this driver would be appropriate PC/SC Smartcard Service Provider (SSP) software. The data then passes to the terminal application 136, which must handle the capabilities provided by the particular card application 126z being run. In this manner, commands and responses pass back and forth between the terminal application 136 and the selected card application 126z. The terminal application interacts with the user, receiving commands from the user, some of which are passed to the selected Java card application 126z, and receiving responses from the Java card application 126z, which are processed and passed back to the user. Referring to Fig. 14, the Card JVM 16 is an interpreter that interprets a card application 126x. The memory resources in the microcontroller that impact the Card JVM 16 are the Card ROM 140, Card RAM 141 and the Card EEPROM 142. The Card ROM 140 is used to store the Card JVM 16 and the card operating system 122. Card ROM 140 may also be used to store fixed card applications 140a and class libraries 140b. Loadable applications 141a, 141b and libraries 141c may also be stored in Card RAM 141. The Card JVM 16 interprets a card application 141a, 141b, or 140a. The Card JVM 16 uses the Card RAM to store the VM stack 144a and system state variables 144b. The Card JVM 16 keeps track of the operations performed via the VM stack 144a. The objects created by the Card JVM 16 are either on the RAM heap 144c, in the EEPROM heap 146a, or in the file system 147.
All of the heap manipulated by the Card JVM 16 may be stored in the Card RAM 141 as a RAM Heap 144c, or it may be distributed across to the Card EEPROM 142 as a EEPROM Heap 146a. Card RAM 141 is also used for recording the state of the system stack 148 that is used by routines written in the native code of the microcontroller. The Card JVM 16 uses the Card EEPROM 142 to store application data either in the EEPROM heap 146a or in the file system 147. Application data stored in a file may be manipulated via an interface to the card operating system 122. This interface is provided by a class library 140b stored in Card ROM 140, by a loadable class library 141c stored in Card EEPROM 142. One such interface is described in Appendix F. Applications and data in the card are isolated by a firewall mechanism 149.
To cope with the limited resources available on microcontrollers, the Card JVM 16 implements a strict subset of the Java programming language. Consequently, a Java application 20 compiles into a class file that contains a strict subset of Java byte codes. This enables application programmers to program in this strict subset of Java and still maintain compatibility with existing Java Virtual Machines. The semantics of the Java byte codes interpreted by the Card JVM 16 are described in the aforementioned Java Virtual Machine Specification. The subset of byte codes interpreted by the Card JVM 16 can be found in Appendix C. The card class file converter 26 checks the Java application 20 to ensure use of only the features available in this subset and converts into a form that is understood and interpreted by the Card JVM 16.
In other embodiments, the Card JVM 16 is designed to interpret a different set or augmented set of byte codes 116. Although a different byte code set might lead to some performance improvements, departing from a strict Java subset may not be desirable from the point of view of security that is present in the original Java byte codes or compatibility with mainstream Java development tools .
All Card JVM 16 applications 126 have a defined entry point denoted by a class and a method in the class. This entry point is mapped in the string to ID input map 30 and assigned by the card class file converter 26.
Classes, methods and fields within a Java application 20 are assigned IDs by the card class file converter 26. For example, the ID corresponding to the main application class may be defined as F001 and the ID corresponding to its main method, such as "main()V" could be defined as F002.
The overall execution architecture of the Card JVM is described by the flowchart in Fig. 15. Execution of the Card JVM 16 begins at the execution control 120, which chooses a card application 126z to execute. It proceeds by finding and assigning an entry point 152 (a method) in this card application for the Card JVM 16 to interpret. The Card JVM 16 interprets the method 153. If the interpretation proceeds successfully 154, the Card JVM 16 reports success 155 returning control back to the execution control 120. If in the course of interpretation 153 the Card JVM 16 encounters an unhandled error or exception (typically a resource limitation or a security violation) , the Card JVM 16 stops 156 and reports the appropriate error to the terminal 14.
An essential part of the Card JVM 16 is a subroutine that handles the execution of the byte codes. This subroutine is described by the flowchart in Fig. 16. Given a method 160 it executes the byte codes in this method. The subroutine starts by preparing for the parameters of this method 161. This involves setting the VM stack 144a pointer, VM stack 144a frame limits, and setting the program counter to the first byte code of the method.
Next, the method flags are checked 162. If the method is flagged native, then the method is actually a call to native method code (subroutine written in the microcontroller's native processor code). In this case, the Card JVM 16 prepares for an efficient call 163 and return to the native code subroutine. The parameters to the native method may be passed on the VM stack 144a or via the System stack 148. The appropriate security checks are made and the native method subroutine is called. On return, the result (if any) of the native method subroutine is placed on the VM stack 144a so that it may be accessed by the next byte code to be executed. The dispatch loop 164 of the Card JVM 16 is then entered. The byte code dispatch loop is responsible for preparing, executing, and retiring each byte code. The loop terminates when it finishes interpreting the byte codes in the method 160, or when the Card JVM 16 encounters a resource limitation or a security violation. If a previous byte code caused a branch to be taken 165 the Card JVM prepares for the branch 165a. The next byte code is retrieved 165b. In order to keep the cost of processing each byte code down, as many common elements such as the byte code arguments, length, type are extracted and stored.
To provide the security offered by the security model of the programming language, byte codes in the class file must be verified and determined conformant to this model. These checks are typically carried out in prior art by a program referred to as the byte code verifier, which operates in four passes as described in the Java Virtual Machine Specification. To offer the run-time security that is guaranteed by the byte code verifier, the Card JVM 16 must perform the checks that pertain to the Pass 3 and Pass 4 of the verifier. This checking can be bypassed by the Card JVM 16 if it can be guaranteed (which is almost impossible to do) that the byte codes 60 interpreted by the Card JVM 16 are secure. At the minimum, code security can be maintained as long as object references cannot be faked and the VM stack
144a and local variable bounds are observed. This requires checking the state of the VM stack 144a with respect to the byte code being executed.
To enforce the security model of the programming language, a 256-byte table is created as shown in Appendix G which is hereby incorporated by reference. This table is indexed by the byte code number. This table contains the type and length information associated with the indexing byte code. It is encoded with the first 5 bits representing type, and the last 3 bits representing length. The type and length of the byte code is indexed directly from the table by the byte code number. This type and length is then used for checking as shown in Appendix H which is hereby incorporated by reference. In Appendix H, the checking process begins by decoding the length and type from the table in Appendix G which is hereby incorporated by reference. The length is used to increment the program counter. The type is used first for pre-execution checking, to insure that the data types on the VM stack 144a are correct for the byte code that is about to be executed. The 256 bytes of ROM for table storage allows the original Java byte codes to be run in the Card JVM 16 and minimizes the changes required to the Java class file to be loaded in the card. Additional Java byte codes can be easily supported since it is relatively easy to update the appropriate table entries .
In other embodiments, as shown in Fig. 10, the Java byte codes in the method are renumbered in such a manner that the byte code type and length information stored in the table in Appendix H is implicit in the reordering. Appendix H is hereby incorporated by reference. Consequently, the checks that must be performed on the state of the VM stack 144a and the byte code being processed does not have to involve a table look up. The checks can be performed by set of simple comparisons as shown in Appendix I which is hereby incorporated by reference. This embodiment is preferable when ROM space is at a premium, since it eliminates a 256-byte table. However adding new byte codes to the set of supported byte codes has to be carefully thought out since the new byte codes have to fit in the implicit numbering scheme of the supported byte codes .
In another embodiment, the Card JVM 16 chooses not to perform any security checks in favor of Card JVM 16 execution speed. This is illustrated in the flowchart in Fig. 18. The flow chart in Fig. 18 is the same as that of Fig. 16 with the security checks removed. This option is not desirable from the point of view of security, unless it can be guaranteed that the byte codes are secure .
The Card JVM 16 may enforce other security checks as well. If the byte code may reference a local variable, the Card JVM 16 checks if this reference is valid, throwing an error if it is not. If the reference is valid, the Card JVM 16 stores the type of the local variable for future checking. The VM stack 144a pointer is checked to see if it is still in a valid range. If not an exception is thrown. The byte code number is checked. If it is not supported, an exception is thrown. Finally, the byte code itself is dispatched 165d. The byte codes translated by the Card JVM 16 are listed in Appendix C. The semantics of the byte codes are described in the aforementioned Java Virtual Machine Specification with regard to the state of the VM stack 144a before and after the dispatch of the byte code. Note also that some byte codes (the byte codes, INVOKESTATIC, INVOKESPECIAL, INVOKENONVIRTUAL and INVOKEVIRTUAL) may cause reentry into the Card JVM 16, requiring processing to begin at the entry of the subroutine 161. Fig. 17 shows the flowchart of the byte code execution routine. The routine is given a byte code 171 to execute. The Card JVM 16 executes 172 the instructions required for the byte code. If in the course of executing the Card JVM 16 encounters a resource limitation 173, it returns an error 156. This error is returned to the terminal 16 by the Card JVM 16. If the byte code executes successfully, it returns a success 175. After execution, the type of the result is used to set the VM stack 144a state correctly 165e, properly flagging the data types on the VM stack 144a. The byte code information gathered previously 165b from the byte code info table is used to set the state of the VM stack 144a in accordance with the byte code that just executed.
In other embodiments, setting the output state of the VM stack 144a with respect to the byte code executed is simplified if the byte code is renumbered. This is shown in Appendix I which is hereby incorporated by reference.
In yet another embodiment, the Card JVM 16 may bypass setting the output state of the VM stack 144a in favor of Card JVM 16 execution speed. This option is not desirable from the point of view of security, unless it can be guaranteed that the byte codes are secure.
After the byte code has been executed, the byte code is retired 165f. This involves popping arguments off the VM stack 144a. Once byte code processing is completed, the loop 164 is repeated for the next byte code for the method.
Once the dispatch loop 164 terminates, the VM stack 144a is emptied 166. This prevents any object references filtering down to other Card JVM 16 invocations and breaking the Card JVM's 16 security. Termination 167 of the byte code dispatch loop 164 indicates that the Card JVM 16 has completed executing the requested method.
To isolate data and applications in the integrated circuit card 10 from each other, the integrated circuit card 10 relies on the firewall mechanism 149 provided by the Card JVM 16. Because the Card JVM implements the standard pass 3 and pass 4 verifier checks, it detects any attempt by an application to reference the data or code space used by another application, and flag a security error 156. For example, conventional low level applications can cast non-reference data types into references, thereby enabling access to unauthorized memory space, and violating security. With this invention, such an attempt by a card application 126z to use a non-reference data type as a reference will trigger a security violation 156. In conventional Java, this protected application environment is referred to as the sandbox application-interpretation environment. However, these firewall facilities do not work independently. In fact, the facilities are overlapping and mutually reinforcing with conventional access control lists and encryption mechanisms shown in the following table :
Figure imgf000034_0001
Figure imgf000035_0001
Taken together, these facilities isolate both data and applications on the integrated circuit card 10 and ensure that each card application 126 can access only the authorized resources of the integrated circuit card 10.
Referring to Fig. 19, card applications 126x, 126y, 126z can be endowed with specific privileges when the card applications 126 execute. These privileges determine, for example, which data files the card applications 126 can access and what operations the card applications 126 can perform on the file system 147. The privileges granted to the card applications 126 are normally set at the time that a particular card application 126z is started by the user, typically from the terminal 14.
The integrated circuit card 10 uses cryptographic identification verification methods to associate an identity 190 (e.g., identities 190a, 190b and 190c) and hence, a set of privileges to the execution of the card application 126. The association of the specific identity 190c to the card application 126z is made when the card application 126z begins execution, thus creating a specific running application 200, as shown in Fig. 20. The identity 190 is a unique legible text string reliably associated with an identity token. The identity token (e.g., a personal identification number (PIN) or a RSA private key) is an encryption key. Referring to Fig. 20, in order to run a specific card application 126z, the identity 190c of the card application 126z must be authenticated. The identity 190c is authenticated by demonstrating knowledge of the identity token associated with the identity 190c.
Therefore, in order to run the card application 126z, an agent (e.g., a card holder or another application wishing to run the application) must show that it possesses or knows the application's identity-defining encryption key. One way to demonstrate possession of an encryption key is simply to expose the key itself. PIN verification is an example of this form of authentication. Another way to demonstrate the possession of an encryption key without actually exposing the key itself is to show the ability to encrypt or decrypt plain text with the key. Thus, a specific running application 200 on the integrated circuit card 10 includes a card application 126z plus an authenticated identity 190c. No card application 126 can be run without both of these elements being in place. The card application 126z defines data processing operations to be performed, and the authenticated identity 190c determines on what computational objects those operations may be performed. For example, a specific application 126z can only access identity C's files 202 in the file system 147 associated with the specific identity 190c, and the specific card application 126z cannot access other files 204 that are associated with identities other than the specific identity 190c. The integrated circuit card 10 may take additional steps to ensure application and data isolation. The integrated circuit card 10 furnishes three software features sets: authenticated-identity access control lists; a Java-based virtual machine; and one-time session encryption keys to protect data files, application execution, and communication channels, respectively. Collectively, for one embodiment, these features sets provide the application data firewalls 149 for one embodiment. The following discusses each software feature set and then shows how the three sets work together to insure application and data isolation on the integrated circuit card 10.
An access control list (ACL) is associated with every computational object (e.g., a data file or a communication channel) on the integrated circuit card 10 that is be protected, i.e., to which access is to be controlled. An entry on an ACL (for a particular computational object) is in a data format referred to as an e-tuple: type : identity permissions
The type field indicates the type of the following identity (in the identity field), e.g., a user (e.g., "John Smith"), or a group. The permissions field indicates a list of operations (e.g., read, append and update) that can be performed by the identity on the computational object.
As an example, for a data file that has the ACL entry:
USER :AcmeAir1ines : RAU, any application whose identity is "AcmeAirlines" can read ("R"), append ("A") and update ("U") the data file. In addition, the ACL may be used selectively to permit the creation and deletion of data files. Furthermore, the ACL may be used selectively to permit execution of an application.
Whenever a computational object is accessed by a running application 200, the access is intercepted by the Card JVM 16 and passed to the card operating system 122, which determines if there is an ACL associated with the object. If there is an associated ACL, then the identity 190c associated with the running application 200 is matched on the ACL. If the identity is not found or if the identity is not permitted for the type of access that is being requested, then the access is denied. Otherwise, the access is allowed to proceed.
Referring to Fig. 13, to prevent the potential problems due to the single data path between the integrated circuit card 10 and the terminal 14, communication channel isolation is accomplished by including in the identity authentication process the exchange of a one-time session key 209 between the a card application 126z and the terminal application 136. The key 209 is then used to encrypt subsequent traffic between the authenticating terminal application 136 and the authenticated card application 126z. Given the one-time session key 209, a rogue terminal application can neither "listen in" on an authenticated communication between the terminal 14 and the integrated circuit card 10, nor can the rogue terminal application "spoof" the card application into performing unauthorized operations on its behalf.
Encryption and decryption of card/terminal traffic can be handled either by the card operating system 122 or by the card application itself 126z. In the former case, the communication with the terminal 14 is being encrypted transparently to the application, and message traffic arrives decrypted in the data space of the application. In the latter case, the card application 126z elects to perform encryption and decryption to provide an extra layer of security since the application could encrypt data as soon as it was created and would decrypt data only when it was about to be used. Otherwise, the data would remain encrypted with the session key 209.
Thus, the application firewall includes three mutually reinforcing software sets. Data files are protected by authenticated-identity access control lists. Application execution spaces are protected by the Card JVM 16. Communication channels are protected with one-time session encryption keys 209. In other embodiments, the above-described techniques are used with a microcontroller (such as the processor 12) may control devices (e.g., part of an automobile engine) other than an integrated circuit card. In these applications, the microcontroller provides a small platform (i.e., a central processing unit, and a memory, both of which are located on a semiconductor substrate) for storing and executing high level programming languages. Most existing devices and new designs that utilize a microcontroller could use this invention to provide the ability to program the microcontroller using a high level language, and application of this invention to such devices is specifically included.
The term application includes any program, such as Java applications, Java applets, Java aglets, Java servlets, Java commlets, Java components, and other non- Java programs that can result in class files as described below.
Class files may have a source other than Java program files. Several programming languages other than Java also have compilers or assemblers for generating class files from their respective source files. For example, the programming language Eiffel can be used to generate class files using Pirmin Kalberer's "J-Eiffel", an Eiffel compiler with JVM byte code generation (web site: http://www.spin.ch/~kalberer/jive/index.htm). An Ada 95 to Java byte code translator is described in the following reference (incorporated herein by reference) : Taft, S. Tucker, "Programming the Internet in Ada 95", proceedings of Ada Europe '96, 1996. Jasmin is a Java byte code assembler that can be used to generate class files, as described in the following reference (incorporated herein by reference) : Meyer, Jon and Troy Downing, "Java Virtual Machine", O'Reilly, 1997. Regardless of the source of the class files, the above description applies to languages other than Java to generate codes to be interpreted.
Fig. 21 shows an integrated circuit card, or smart card, which includes a microcontroller 210 that is mounted to a plastic card 212. The plastic card 212 has approximately the same form factor as a typical credit card. The communicator 12a can use a contact pad 214 to establish a communication channel, or the communicator 12a can use a wireless communication system. In other embodiments, a microcontroller 210 is mounted into a mobile or fixed telephone 220, effectively adding smart card capabilities to the telephone, as shown in Fig. 22. In these embodiments, the microcontroller 210 is mounted on a module (such as a Subscriber Identity Module (SIM) ) , for insertion and removal from the telephone 220.
In other embodiments, a microcontroller 210 is added to a key ring 230 as shown in Fig. 23. This can be used to secure access to an automobile that is equipped to recognize the identity associated with the microcontroller 210 on the key ring 230.
Jewelry such as a watch or ring 240 can also house a microcontroller 210 in an ergonomic manner, as shown in Fig. 24. Such embodiments typically use a wireless communication system for establishing a communication channel, and are a convenient way to implement access control with a minimum of hassle to the user.
Fig. 25 illustrates a microcontroller 210 mounted in an electrical subsystem 252 of an automobile 254. In this embodiment, the microcontroller is used for a variety of purposes, such as to controlling access to the automobile, (e.g. checking identity or sobriety before enabling the ignition system of the automobile) , paying tolls via wireless communication, or interfacing with a global positioning system (GPS) to track the location of the automobile, to name a few.
While specific embodiments of the present invention have been described, various modifications and substitutions will become apparent to one skilled in the art by this disclosure. Such modifications and substitutions are within the scope of the present invention, and are intended to be covered by the appended claims .
APPENDIX A
Card Class File Format For Preferred Embodiment
Introduction
The card class file is a compressed form of the original class file(s). The card class file contains only the semantic information required to interpret Java programs from the original class files. The indirect references in the original class file are replaced with direct references resulting in a compact representation. The card class file format is based on the following principles:
Stay close to the standard class file format. The card class file format should remain as close to the standard class file format as possible. The Java byte codes in the class file remain unaltered. Not altering the byte codes ensures that the structural and static constraints on them remain verifiably intact.
Ease of implementation: The card class file format should be simple enough to appeal to Java Virtual Machine implementers. It must allow for different yet behaviorally equivalent implementations.
Feasibility. The card class file format must be compact in order to accommodate smart card technology. It must meet the constraints of today's technology while not losing sight of tomorrow's innovations.
This document is based on Chapter 4, "The class file format", in the book titled "The Java™ Virtual Machine Specification"[1], henceforth referred to as the Red book. Since the document is based on the standard class file format described in the Red book, we only present information that is different. The Red book serves as the final authority for any clarification.
The primary changes from the standard class file format are:
The constant pool is optimized to contain only 16-bit identifiers and, where possible, indirection is replaced by a direct reference. Attributes in the original class file are eliminated or regrouped. The Java Card class File Format This section describes the Java Card class file format. Each card class file contains one or many Java types, where a type may be a class or an interface. A card class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively. Multi-byte data items are always stored in big-endian order, where the high bytes come first. In Java, this format is supported by interfaces java.io.Datalnput and java.io.DataOutput and classes such as java.io.DatalnputStream and java.io.DataOutputStream.
We define and use the same set of data types representing Java class file data: The types u , u2, and u4 represent an unsigned one-, two-, or four-byte quantity, respectively. In Java, these types may be read by methods such as readUnsignedByte, readUnsignedShort, and readint of the interface java.io.Datalnput. The card class file format is presented using pseudo-structures written in a C-like structure notation. To avoid confusion with the fields of Java Card Virtual Machine classes and class instances, the contents of the structures describing the card class file format are referred to as items. Unlike the fields of a C structure, successive items are stored in the card class file sequentially, without padding or alignment. Variable-sized tables, consisting of variable-sized items, are used in several class file structures. Although we will use C-like array syntax to refer to table items, the fact that tables are streams of varying-sized structures means that it is not possible to directly translate a table index into a byte offset into the table. Where we refer to a data structure as an array, it is literally an array. In order to distinguish between the card class file structure and the standard class file structure, we add capitalization; for example, we rename fieldjnfo in the original class file to Fieldlnfo in the card class file. Card Class File
A card class file contains a single CardClassFile structure: CardClassFile { u1 major_version; u1 minor_version; u2 namejndex; u2 cons t_size; u2 max_class;
Cplnfo constant_pool[const_size];
Classlnfo class[max_class]; } The items in the CardClassFile structure are as follows: minor_version, major_version
The values of the minor_version and major_version items are the minor and major version numbers of the off-card Java Card Virtual Machine that produced this card class file. An implementation of the Java Card Virtual Machine normally supports card class files having a given major version number and minor version numbers 0 through some particular minor_version.
Only the Java Card Forum may define the meaning of card class file version numbers. name_index
The value of the namejndex item must represent a valid Java class name. The Java class name represented by namejndex must be exactly the same Java class name that corresponds to the main application that is to run in the card. A card class file contains several classes or interfaces that constitute the application that runs in the card. Since Java allows each class to contain a main method there must be a way to distinguish the class file containing the main method which corresponds to the card application. const_size
The value of const_size gives the number of entries in the card class file constant pool.
A constant_pool index is considered valid if it is greater than or equal to zero and less than cons t_size. max_class
This value refers to the number of classes present in the card class file. Since the name resolution and linking in the Java Card are done by the off-card Java Virtual Machine all the class files or classes required for an application are placed together in one card class file. constant_pool_
The constant_pool is a table of variable-length structures () representing various string constants, class names, field names, and other constants that are referred to within the
CardClassFile structure and its substructures.
The first entry in the card class file is constant_pool[0].
Each of the constant_pool table entries at indices 0 through cons t_size is a variable-length structure (). classQ
The class is a table of max_class classes that constitute the application loaded onto the card. Constant Pool
All constantjpool table entries have the following general format: Cplnfo { ui tag; u1 info[];
} Each item in the constant_pool table must begin with a 1-byte tag indicating the kind of cpjnfo entry. The contents of the info array varies with the value of tag. The valid tags and their values are the same as those specified in the Red book. Each tag byte must be followed by two or more bytes giving information about the specific constant. The format of the additional information varies with the tag value. Currently the only tags that need to be included are CONSTANT_Class, CONSTANT_FieldRef, CONSTANTj ethodRef and CONSTANTJnterfaceRef. Support for other tags be added as they are included in the specification. CONSTANT_Class The CONSTAN.T_Class_info structure is used to represent a class or an interface:
CONSTANT_Classinfo { ui tag; u2 namejndex;
} The items of the CONSTANT_Class_info structure are the following: tag
The tag item has the value CONSTANT_Class (7). namejndex
The value of the namejndex item must represent a valid Java class name. The Java class name represented by namejndex must be exactly the same Java class name that is described by the corresponding CONSTANT_Class entry in the constant_pool of the original class file.
CONSTANT_Fieldref, CONSTANT_Methodref, and CONSTANTJnterfaceMethodref Fields, methods, and interface methods are represented by similar structures: CONSTANT_Fieldreflnfo { u1 tag; u2 classjndex; u2 name_sig_index;
} CONSTANT_Methodreflnfo { u1 tag; u2 classjndex; u2 name_sig_index;
} CONSTANTJnterfaceMethodreflnfo { u1 tag; u2 classjndex; u2 name_sigj'ndex;
} The items of these structures are as follows: tag
The tag item of a CONSTANT_Fieldreflnfo structure has the value CONSTANT_Fieldref (9).
The tag item of a CONSTANTjVlethodreflnfo structure has the value CONSTANTj ethodref (10).
The tag item of a CONSTANTJnterfaceMethodreflnfo structure has the value CONSTANTJnterfaceMethodref (11). classsjndex
The value of the classjndex item must represent a valid Java class or interface name. The name represented by classjndex must be exactly the same name that is described by the corresponding CONSTANT_Class_info entry in the constant_pool of the original class file. name_sig ndex
The value of the name_sig_index item must represent a valid Java name and type. The name and type represented by name_sig_index must be exactly the same name and type described by the CONSTANT_NameAndType_info entry in the constant_pool structure of the original class file. Class
Each class is described by a fixed-length Classlnfo structure. The format of this structure is: Classlnfo { u2 namejndex; u1 max_field; ui max sfield; u1 maxjnethod; u1 maxjnterface; u2 superclass; u2 access_flags;
Fieldlnfo field[max_field+max_sfield];
Interfacelnfo interface[max_interface];
Methodlnfo method[max_method];
} The items of the Classlnfo structure are as follows: namejndex
The value of the namejndex item must represent a valid Java class name. The Java class name represented by namejndex must be exactly the same Java class name that is described in the corresponding ClassFile structure of the original class file. max ^ield
The value of the max_field item gives the number of Fieldlnfo () structures in the field table that represent the instance variables, declared by this class or interface type. This value refers to the number of non-static the fields in the card class file. If the class represents an interface the value of max_field is 0. max_sfϊeld
The value of the max_sfield item gives the number of Fieldlnfo structures in the field table that represent the class variables, declared by this class or interface type. This value refers to the number of static the fields in the card class file. maxjnethod
The value of the maxjnethod item gives the number of Methodlnfo () structures in the method table. maxjnterface
The value of the maxjnterface item gives the number of direct superinterfaces of this class or interface type. superclass
For a class, the value of the superclass item must represent a valid Java class name.
The Java class name represented by superclass must be exactly the same Java class name that is described in the corresponding ClassFile structure of the original class file.
Neither the superclass nor any of its superclasses may be a final class.
If the value of superclass is 0, then this class must represent the class Java. lang. Object, the only class or interface without a superclass. For an interface, the value of superclass must always represent the Java class Java. lang. Object. access_flags
The value of the access_flags item is a mask of modifiers used with class and interface declarations. The access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding ClassFile structure of the original class file. fieldQ
Each value in the field table must be a fixed-length Fieldlnfo () structure giving a complete description of a field in the class or interface type. The field table includes only those fields that are declared by this class or interface. It does not include items representing fields that are inherited from superclasses or superinterfaces. interface!]
Each value in the interface array must represent a valid interface name. The interface name represented by each entry must be exactly the same interface name that is described in the corresponding interface array of the original class file. methodQ
Each value in the method table must be a variabie-length Methodlnfo () structure giving a complete description of and Java Virtual Machine code for a method in the class or interface.
The Methodlnfo structures represent all methods, both instance methods and, for classes, class (static) methods, declared by this class or interface type. The method table only includes those methods that are explicitly declared by this class. Interfaces have only the single method <clinit>, the interface initialization method. The methods table does not include items representing methods that are inherited from superclasses or superinterfaces. Fields
Each field is described by a fixed-length fieldj'nfo structure. The format of this structure is Fieldlnfo { u2 namejndex; u2 signaturejndex; u2 access_flags;
} The items of the Fieldlnfo structure are as follows: name index The value of the namejndex item must represent a valid Java field name. The Java field name represented by namejndex must be exactly the same Java field name that is described in the corresponding fieldjnfo structure of the original class file. signaturejndex
The value of the signaturejndex item must represent a valid Java field descriptor. The
Java field descriptor represented by signature index must be exactly the same Java field descriptor that is described in the corresponding fieldjnfo structure of the original class file. access ^lags
The value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a field. The access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding fieldjnfo structure of the original class file.
Methods
Each method is described by a variable-length Methodlnfo structure. The Methodlnfo structure is a variable-length structure that contains the Java Virtual Machine instructions and auxiliary information for a single Java method, instance initialization method, or class or interface initialization method. The structure has the following format:
Methodlnfo { u2 namejndex; u2 signaturejndex; u1 maxjocal; u1 max_arg; u1 max_stack; u1 access_flags; u2 codejength; u2 exceptionjength; u1 code[code_Iength];
{ u2 start Dc; u2 end JDC; u2 handler_pc; u2 catch_type;
} einfo[exception_length]; } The items of the Methodlnfo structure are as follows: namejndex
The value of the namejndex item must represent either one of the special intemal method names, either <init> or <clinit>, or a valid Java method name. The Java method name represented by namejndex must be exactly the same Java method name that is described in the corresponding method j'nfo structure of the original class file. signaturejndex
The value of the signaturejndex item must represent a valid Java method descriptor.
The Java method descriptor represented by signaturejndex must be exactly the same
Java method descriptor that is described in the corresponding method j'nfo structure of the original class file. max ocal
The value of the maxjocals item gives the number of local variables used by this method, excluding the parameters passed to the method on invocation. The index of the first local variable is 0. The greatest local variable index for a one-word value is max_Iocals-1. max_arg
The value of the max_arg item gives the maximum number of arguments to this method. max_stack
The value of the max_stack item gives the maximum number of words on the operand stack at any point during execution of this method. access_flags
The value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a method or instance initialization method. . The access_flags modifiers and their values are the same as the access_flags modifiers in the corresponding method j'nfo structure of the original class file. codejength
The value of the codejength item gives the number of bytes in the code array for this method. The value of codejength must be greater than zero; the code array must not be empty. exceptionjength
The value of the exceptionjength item gives the number of entries in the exceptionjnfo table. codeQ - 4 Λ n9 -
The code array gives the actual bytes of Java Virtual Machine code that implement the method. When the code array is read into memory on a byte addressable machine, if the first byte of the array is aligned on a 4-byte boundary, the tableswitch and lookupswitch 32-bit offsets will be 4-byte aligned; refer to the descriptions of those instructions for more information on the consequences of code array alignment.
The detailed constraints on the contents of the code array are extensive and are the same as described in the Java Virtual Machine Specification. einfoQ
Each entry in the einfo array describes one exception handler in the code array. Each einfo entry contains the following items: startjpc, endjpc
The values of the two items start_pc and end_pc indicate the ranges in the code array at which the exception handler is active.
The value of startjpc must be a valid index into the code array of the opcode of an instruction. The value of endjpc either must be a valid index into the code array of the opcode of an instruction, or must be equal to codejength, the length of the code array.
The value of start_pc must be less than the value of endjpc.
The startjpc is inclusive and endjpc is exclusive; that is, the exception handler must be active while the program counter is within the interval [startjpc, endjpc]. handlerjpc
The value of the handlerjpc item indicates the start of the exception handler. The value of the item must be a valid index into the code array, must be the index of the opcode of an instruction, and must be less than the value of the codejength item. catch_type
If the value of the catch Jype item is nonzero, it must represent a valid Java class type.
The Java class type represented by catch ype must be exactly the same as the Java class type that is described by the catchjype in the corresponding methodjnfo structure of the original class file. This class must be the class Throwable or one of its subclasses. The exception handler will be called only if the thrown exception is an instance of the given class or one of its subclasses.
If the value of the catchjype item is zero, this exception handler is called for all exceptions. This is used to implement finally.
Attributes
Attributes used in the original class file are either eliminated or regrouped for compaction. The predefined attributes SourceFile, ConstantValue, Exceptions, LineNumberTable, and Local-VariableTable may be eliminated without sacrificing any information required for Java byte code interpretation.
The predefined attribute Code which contains all the byte codes for a particular method are moved in the corresponding Methodlnfo structure.
Constraints on Java Card Virtual Machine Code
The Java Card Virtual Machine code for a method, instance initialization method, or class or interface initialization method is stored in the array code of the Methodlnfo structure of a card class file. Both the static and the structural constraints on this code array are the same as those described in the Red book.
Limitations of the Java Card Virtual Machine and Java Card class File Format
The following limitations in the Java Card Virtual Machine are imposed by this version of the Java Card Virtual Machine specification:
The per-card class file constant pool is limited to 65535 entries by the 16-bit cons t_size field of the CardClassFile structure (). This acts as an internal limit on the total complexity of a single card class file. This count also includes the entries corresponding to the constant pool of the class hierarchy available to the application in the card. The amount of code per method is limited to 65535 bytes by the sizes of the indices in the Methodlnfo structure. The number of local variables in a method is limited to 255 by the size of the maxjocal item of the Methodlnfo structure (). The number of fields of a class is limited to 510 by the size of the max_field and the max_sfield items of the Classlnfo structure (). The number of methods of a class is limited to 255 by the size of the maxjriethod item of the Classlnfo structure (). The size of an operand stack is limited to 255 words by the max_stack field of the
Methodlnfo structure (). Bibliography
[1] Tim Lindholm and Frank Yellin, The Java Virtual Machine Specification, Addison-Wesley, 1996. APPENDIX B
String To ID Input And Output
For the correct operation of Card JVM it is very important that the declared and generated IDs are correctly managed. This management is controlled by the definitions in the string to ID input file String-ID INMap. This textual file, the basis for which is shown below, declares which areas of the namespace can be used for what purposes. One possible arrangement of this map may reserve some IDs for internal use by the Card JVM interpreter, and the rest is allocated to Card JVM applications.
#
# String-ID INMap file.
# 4000 - 7FFF Available for application use.
# F000 - FFFE Reserved for Card JVM's internal use.
# constantBase FO I00 # The area from F000 to FFFF is reserved for
# Card JVM's intemal use. #
MainApplication # F000 - Name of the startup class
# (changes for each application) main()V # F001 - Name of the startup method
# (may change for each application) java/lang/Object # F002 java/lang/String # F003
<init>()V # F004
<clinit>()V # F005
[L # F006
[I # F007
[C # F008
[B # F009
[S # F000A
# constantBase FF FO # This area is reserved for simple return types
L # FFF0 V # FFF1 1 # FFF2
S # FFF3
C # FFF4
B # FFF5 z # FFF6
# constantBase 4000 # # FFrroomm here on this space is application dependent.
Essentially, all applications which are to be loaded into a smart card are allocated their own IDs within the 0x4000 to 0x7FFF. This space is free for each application since no loaded application is permitted to access other applications.
Care must be taken on managing the IDs for preloaded class libraries. The management of these IDs is helped by the (optional) generation of the string to ID output file String-ID OUTMap file. This map is the String-ID INMap augmented with the new String-ID bindings. These bindings may be produced when the Card Class File Converter application terminates. The String-ID OUTMap is generated for support libraries and OS interfaces loaded on the card. This map may be used as the String-ID INMap for smart card applications using the support libraries and OS interfaces loaded on the card. When building new applications this file can generally be discarded.
-..
- o -
As an example consider the following Java program, HelloSmartCard.java. When compiled it generates a class file HelloSmartCard. class. This class file has embedded in it strings that represent the class name, methods and type information. On the basis of the String-ID INMap described above Card Class File Converter generates a card class file that replaces the strings present in the class file with IDs allocated by Card Class File Converter. Table 1 lists the strings found in the constant pool of HelloSmartCard. class with their respective Card Class File Converter assigned IDs. Note that some strings (like "java/lang/Object") have a pre-assigned value (F002) and some strings (like "()V") get a new value (4004).
Program : HelloSmartCard.java
public class HelloSmartCard { public byte aVariable;
public static void mainQ { HelloSmartCard h = new HelloSmartCard(); h.aVariable = (byte)13; } } Relevant entries of String-ID OUTMap
APPENDIX C
Byte codes supported by the Card JVM in the preferred embodiment
AALOAD AASTORE ACONSTJMULL
ALOAD ALOAD_0 ALOAD
ALOAD_2 ALOAD_3 ARETURN
ARRAYLENGTH ASTORE ASTORE_0
ASTORE_1 ASTORE_2 ASTORE_3
ATHROW BALOAD BASTORE
CHECKCAST DUP DUP2
DUP2_X1 DUP2_X2 DUP_X1
DUP_X2 GETFIELD GETSTATIC
GOTO IADD IALOAD
IAND IASTORE ICONST_0
ICONSTJ ICONST_2 ICONST_3
ICONST_4 ICONST_5 ICONST_M1
IDIV IFEQ IFGE
IFGT IFLE IFLT
IFNE IFNONNULL IFNULL
IF_ACMPEQ IF_ACMPNE IFJCMPEQ
IFJCMPGE IFJCMPGT IFJCMPLE
IFJCMPLT IFJCMPNE IINC
ILOAD ILOAD_0 ILOAD_1
ILOAD_2 ILOAD_3 IMUL
INEG INSTANCEOF INT2BYTE
INT2CHAR INT2SHORT INVOKEINTERFACE
INVOKENONVIRTUAL INVOKESTATIC INVOKEVIRTUAL
IOR IREM IRETURN
ISHL ISHR ISTORE
ISTOREJD ISTORE ISTORE_2
ISTORE_3 ISUB IUSHR
IXOR JSR LDC1
LDC2 LOOKUPSWITCH NEW
NEWARRAY NOP POP
POP2 PUTFIELD PUTSTATIC
RET RETURN SALOAD
SASTORE SIPUSH SWAP
TABLESWITCH BIPUSH Standard Java byte codes numbers for the byte codes supported in the preferred embodiment
package util;
r
* List of actual Java Bytecodes handled by this JVM
* ref. Lindohlm and Yellin. *
* Copyright (c) 1996 Schlumberger Austin Products Center,
* Schlumberger, Austin, Texas, USA. */
public interface BytecodeDefn { public static final byte j_NOP = (byte)O; public static final byte ACONST_NULL = (byte)1 ; public static final byte ICONSTJVI1 = (byte)2; public static final byte ICONST_0 = (byte)3; public static final byte ICONSTJ = (byte)4; public static final byte ICONST_2 = (byte)5; public static final byte ICONST_3 = (byte)6; public static final byte ICONST_4 = (byte)7; public static final byte ICONST_5 = (byte)8; public static final byte BIPUSH = (byte)16; public static final byte SIPUSH = (byte)17; public static final byte LDC1 = (byte)18; public static final byte LDC2 = (byte)19; public static final byte ILOAD = (byte)21 ; public static final byte ALOAD = (byte)25; public static final byte ILOAD_0 = (byte)26; public static final byte ILOAD_1 = (byte)27; public static final byte ILOAD_2 = (byte)28; public static final byte ILOAD_3 = (byte)29; public static final byte ALOAD_0 = (byte)42; public static final byte ALOAD_1 = (byte)43; public static final byte ALOAD_2 = (byte)44; public static final byte ALOAD_3 = (byte)45; public static final byte IALOAD = (byte)46; public static final byte AALOAD = (byte)50 public static final byte BALOAD = (byte)51 public static final byte CALOAD = (byte)52 public static final byte ISTORE = (byte)54; public static final byte ASTORE = (byte)58; public static final byte ISTORE_0 = (byte)59 public static final byte ISTORE_1 = (byte)60 public static final byte ISTORE_2 = (byte)61 public static final byte ISTORE_3 = (byte)62 public static final byte ASTORE ) = (byte)75 public static final byte ASTORE_1 = (byte)76 public static final byte ASTORE_2 = (byte)77 public static final byte ASTORE_3 = (byte)78 public static final byte IASTORE = (byte)79; public static final byte AASTORE = (byte)83 public static final byte BASTORE = (byte)84 public static final byte CASTORE = (byte)85 public static final byte POP = (byte)87; public static final byte POP2 = (byte)88; public static final byte DUP = (byte)89; public static final byte DUP_X1 = (byte)90; public static final byte DUP_X2 = (byte)91 ; public static final byte DUP2 = (byte)92; public static final byte DUP2_X1 = (byte)93; public static final byte DUP2_X2 = (byte)94; public static final byte SWAP = (byte)95; public static final byte IADD = (byte)96; public static final byte ISUB = (byte)100; public static final byte IMUL = (byte) 104; public static final byte IDIV = (byte)108; public static final byte IREM = (byte)112; public static final byte INEG = (byte)116; public static final byte ISHL = (byte) 120; public static final byte ISHR = (byte) 122; public static final byte IUSHR = (byte)124; public static final byte IAND = (byte)126; public static final byte IOR = (byte)128; public static final byte IXOR = (byte)130; public static final byte MNC = (byte)132; public static final byte INT2BYTE = (byte)145; public static final byte INT2CHAR = (byte)146; public static final byte INT2SHORT = (byte) 147; public static final byte IFEQ = (byte)153; public static final byte IFNE = (byte) 154; public static final byte IFLT = (byte)155; public static final byte IFGE = (byte)156; public static final byte IFGT = (byte)157; public static final byte IFLE = (byte)158; public static final byte IFJCMPEQ = (byte) 159; public static final byte IFJCMPNE = (byte) 160; public static final byte IFJCMPLT = (byte)161 ; public static final byte IFJCMPGE = (byte) 162; public static final byte IFJCMPGT = (byte)163; public static final byte IFJCMPLE = (byte) 164; public static final byte IF_ACMPEQ = (byte) 165; public static final byte IF_ACMPNE = (byte)166; public static final byte GOTO = (byte) 167; public static final byte j_JSR = (byte) 168; public static final byte RET = (byte) 169; public static final byte TABLESWITCH = (byte)170; public static final byte LOOKUPSWITCH = (byte) 171 ; public static final byte IRETURN = (byte) 172; public static final byte ARETURN = (byte) 176; public static final byte RETURN = (byte)177; public static final byte GETSTATIC = (byte)178; public static final byte PUTSTATIC = (byte)179; public static final byte GETFIELD = (byte)180; public static final byte PUTFIELD = (byte)181; public static final byte INVOKEVIRTUAL = (byte) 182; public static final byte INVOKENONVIRTUAL = (byte)183; public static final byte INVOKESTATIC = (byte) 184; public static final byte INVOKEINTERFACE = (byte) 185; public static final byte NEW = (byte) 187; public static final byte NEWARRAY = (byte)188; public static final byte ARRAYLENGTH = (byte)190; public static final byte ATHROW = (byte)191; public static final byte CHECKCAST = (byte) 192; public static final byte INSTANCEOF = (byte) 193; public static final byte IFNULL = (byte) 198; public static final byte IFNONNULL = (byte) 199;
}
- y -
APPENDIX D
Card Class File Converter byte code conversion process
/*
* Reprocess code block. */ static void reprocessMethod(iMethod* imeth)
{ int pc; int npc; int align; bytecode* code; int codelen; int i; int opad; int npad; int ape; int high; int low;
/* codeinfo is a table that keeps track of the valid Java bytecodes and their
* corresponding translation */ code = imeth->external->code; codelen = imeth->external->code_length;
jumpPos = 0; align = 0;
/* Scan for unsupported opcodes */ for (pc = 0; pc < codelen; pc = npc) { if (codeinfo[code[pc]].valid == 0) { errorfUnsupported opcode %d", codefpc]); } npc = nextPC(pc, code); }
/* Scan for jump instructions an insert into jump table */ for (pc = 0; pc < codelen; pc = npc) { npc = nextPC c, code);
if (codeinfo[code[pc]]. valid == 3) { insertJump(pc+1 , pc, (int16)((code[pc+1] « 8)|code[pc+2]));
} else if (codeinfo[code[pc]].valid == 4) { ape = pc & -4; low = (code[apc+8] « 24) | (code[apc+9] « 16)
| (code[apc+10] « 8) | code[apc+11j; high = (code[apc+12] « 24) | (code[apc+13] « 16)
| (code[apc+14] « 8) | code[apc+15]; for (i = 0; i < high-low+1 ; i++) { insertJump(apc+(i*4)+18, pc,
(int16)((code[apc+(i*4)+18] « 8) | code[apc+(i*4)+19]));
} insertJump(apc+6, pc, (int16)((code[apc+6] « 8) | code[apc+7]));
} else if (codeinfo[code[pc]].valid == 5) { ape = pc & -4; low = (code[apc+8] « 24) | (code[apc+9] « 16)
| (code[apc+10] « 8) | code[apc+11]; for (i = 0; i < low; i++) { insertJump(apc+(i*8)+18, pc,
(int16)((code[apc+(i*8)+18] « 8) | code[apc+(i*8)+19]));
} insertJump(apc+6, pc, (int16)((code[apc+6] « 8) | code[apc+7]));
}
} #ifdef TRANSLATE_BYTECODE /* Translate specific opcodes to general ones */ for (pc = 0; pc < codelen; pc = npc) { /* This is a translation code */ if (codeinfo[code[pc]].valid == 2) { switch (code[pc]) { case ILOADJ3: case I OAD l : case ILOAD_2: case ILOAD_3: insertSpace(code, &codelen, pc, 1); align += 1 ; code[pc+1] = codefpc] - ILOADJD; code[pc+0] = ILOAD; break;
case ALOAD_0: case ALOAD_1 : case ALOAD_2: case ALOAD_3: insertSpace(code, &codelen, pc, 1); align += 1 ; code[pc+1] = code[pc] - ALOAD_0; code[pc+0] = ALOAD; break;
case ISTORE_0: case ISTORE_1: case ISTORE_2: case ISTORE_3: insertSpace(code, Scodelen, pc, 1); align += 1 ; code[pc+1] = code[pc] - ISTORE_0; code[pc+0] = ISTORE; break;
case ASTORE_0: case ASTORE_1 : case ASTORE_2: case ASTORE_3: insertSpace(code, &codelen, pc, 1); align += 1 ; code[pc+1] = code[pc] - ASTORE_0; code[pc+0] = ASTORE; break;
case lCONST_M1 : insertSpace(code, &codelen, pc, 2); align += 2; code[pc+2] = 255; code[pc+1] = 255; code[pc+0] = SIPUSH; break;
case ICONST_0: case lCONST_1 : case ICONST_2: case ICONST_3: case ICONST_4: case ICONST_5: insertSpace(code, Scodelen, pc, 2); align += 2; code[pc+2] = codefpc] - ICONST_0; code[pc+1] = 0; code[pc+0] = SIPUSH; break;
case LDC1 : insertSpace(code, &codelen, pc, 1); align += 1 ; code[pc+1] = 0; code[pc+0] = LDC2; break;
case BIPUSH: insertSpace(code, &codelen, pc, 1); align += 1 ; if ((int8)code[pc+2] >= 0) { code[pc+1] = 0;
} else { code[pc+1] = 255;
} code[pc+0] = SIPUSH; break;
case INT2SHORT: removeSpace(code, &codelen, pc, 1); align -= 1 ; npc = pc; continue;
} } else if (codeinfo[code[pc]].vaiid == 4 || codeinfo[code[pc]].valid == 5) {
/* Switches are aligned to 4 byte boundaries. Since we are inserting and
* removing bytecodes, this may change the alignment of switch instructions.
* Therefore, we must readjust the padding in switches to compensate. 7 opad = (4 - (((pc+1) - align) % 4)) % 4; /* Current switch padding */ npad = (4 - ((pc+1) % 4)) % 4; /* New switch padding 7 if (npad > opad) { insertSpace(code, &codelen, pc+1 , npad - opad); align += (npad - opad);
} else if (npad < opad) { removeSpace(code, &codelen, pc+1 , opad - npad); align -= (opad - npad); } npc = nextPC(pc, code);
} #endif
/* Relink constants 7 for (pc = 0; pc < codelen; pc = npc) { npc = nextPC(pc, code); i = (uint16)((code[pc+1] « 8) + code[pc+2]);
switch (code[pc]) { case LDC2: /* ϊ == general index 7 switch (cltem(i).type) { case CONSTANTJnteger: i = cltem(i).v.tint; code[pc] = SIPUSH; break;
case CONSTANT_String: i = buiidStringlndex(i); break;
default: error("Unsupported loading of constant type"); break;
} break;
case NEW: case INSTANCEOF: case CHECKCAST: /* ϊ == class index 7 i = buildClasslndex(i); break;
case GETFIELD: case PUTFIELD:
/* T == field index 7
/* i = buildFieldSignaturelndex(i); 7 i = buildStaticFieldSignaturelndex(i); break;
case GETSTATIC: case PUTSTATIC:
/* T == field index 7 i = buildStaticFieldSignaturelndex(i); break;
case INVOKEVIRTUAL: case INVOKENONVIRTUAL: case INVOKESTATIC: case INVOKEINTERFACE:
/* ϊ == method signature index 7 i = buildSignaturelndex(i); break; }
/* Insert application constant reference 7 code[pc+1] = (i » 8) & OxFF; code[pc+2] = i & OxFF; }
#ifdef MODIFY_BYTECODE /* Translate codes 7 for (pc = 0; pc < codelen; pc = npc) { npc = nextPC(pc, code); code[pc] = codeinfo[code[pc]].translation;
} #endif
/* Relink jumps 7 for (i = 0; i < jumpPos; i++) { ape = jumpTable[i].at; pc = jumpTable[i].from; npc = jumpTable[i].to - pc;
code[apc+0] = (npc » 8) & OxFF; code[apc+1] = npc & OxFF; }
/* Fixup length 7 imeth->extemal->codeJength = codelen; imeth->esize = (SIZEOFMETHOD + codelen + 3) & -4; }
APPENDIX E
Example Loading And Execution Control Program
public class Bootstrap {
// Constants used throughout the program static final byte BUFFER J.ENGTH = 32; static final byte ACK_SIZE = (byte)1 ; static final byte ACK_CODE = (byte)O; static final byte OS_HEADER_SIZE = (byte)Oxl 0; static final byte GPOS_CREATE_FILE = (byte)OxEO;
static final byte ST_INVALID_CLASS = (byte)OxCO; static final byte ST_INVALID_PARAMETER = (byte)OxAO; static final byte ST_INS_NOT_SUPPORTED = (byte)OxBO; static final byte ST_SUCCESS = (byte)OxOO;
static final byte ISO_COMMAND_LENGTH = (byte)5; static final byte ISO_READ_BINARY = (byte)OxBO; static final byte ISO_UPDATE_BINARY = (byte)0xD6; static final byte ISO_INIT_APPLICATION = (byte)0xF2; static final byte ISO_VERIFY_KEY = (byte)0x2A; static final byte ISO_SELECT_FILE = (byte)0xA4;
static final byte ISO_CLASS = (byte)OxCO; static final byte ISO_APP_CLASS = (byte)OxFO;
public static void main () {
byte pbufferrj = new byte[ISO_COMMAND_LENGTH]; byte dbufferD = new byte[BUFFER_LENGTH]; byte ackByte[] = new byte[ACK_SIZE]; //short fileld; short offset; „
- 69/1 -
byte bRetumStatus;
// Initialize Communications _OS.SendATR();
do {
// Retrieve the command header
_OS.GetMessage(pbuffer, ISO_COMMAND_LENGTH, ACK_CODE);
// Verify class of the message - Only ISO + Application if ((pbuffer[0] != ISO_APP_CLASS) && (pbuffer[0] != ISO_CLASS)) { _OS.SendStatus(ST_INVALID_CLASS);
} else {
// go through the switch
// Send the acknowledge code
// Verify if data length too large if (pbuffer[4] > BUFFERJ.ENGTH) { bRetumStatus = ST_INVALID_PARAMETER;
} else
{ switch (pbuffer[1]) { case ISO_SELECT_FILE: // we always assume that length is 2 if (pbuffer[4] != 2) { bRetumStatus = ST_INVALID_PARAMETER;
} else
{
// get the fileld(offset) in the data buffer
_OS.GetMessage(dbuffer, (byte)2, pbuffer[1]); // cast dbuffer[0..1] into a short - 69/2 -
offset = (short) ((dbuffer[0] « 8) | (dbuffer[1] & OxOOFF)); bRetumStatus = _OS.SelectFile(offset);
} break;
case ISO_VERIFY_KEY: // Get the Key from the terminal _OS.GetMessage(dbuffer, pbuffer[4], pbuffer[1]);
bRetumStatus = _OS.VerifyKey(pbuffer[3], dbuffer, pbuffer[4]); break;
case ISOJNIT_APPLICATION: // Should send the id of a valid program file _OS.GetMessage(dbuffer, (byte)1 , pbuffer[1]); // compute fileld(offset) from pbuffer[2..3] via casting offset = (short) ((pbuffer[2] « 8) | (pbuffer[3] & OxOOFF)); bRetumStatus = _OS.Execute(offset, dbuffer[0]); break; case GPOS_CREATE_FILE: if (pbuffer[4] != OS_HEADER_SIZE) { bRetumStatus = ST_INVALID_PARAMETER; break;
}
// Receive The data
_OS.GetMessage(dbuffer, pbuffer[4], pbuffer[1]); bRetumStatus = _OS.CreateFile(dbuffer); break;
case ISO_UPDATE_BINARY: _OS.GetMessage(dbuffer, pbuffer[4], pbuffer[1]); // compute offset from pbuffer[2..3] via casting offset = (short) ((pbuffer[2] « 8) | (pbuffer[3] & OxOOFF)); // assumes that a file is already selected bRetumStatus = _OS.WriteBinaryFile (offset, pbuffer[4], dbuffer); break; case ISO_READ_BINARY: // compute offset from pbuffer[2..3] via casting offset = (short) ((pbuffer[2] « 8) | (pbuffer[3] & OxOOFF)); // assumes that a file is already selected bRetumStatus = JDS.ReadBinaryFile (offset, pbuffer[4], dbuffer); // Send the data if successful ackByte[0] = pbuffer[1]; if (bRetumStatus == ST_SUCCESS) { _OS.SendMessage(ackByte, ACK_SIZE); _OS.SendMessage(dbuffer, pbuffer[4]);
} break; default: bRetumStatus = ST_INS_NOT_SUPPORTED;
}
} JDS.SendStatus(bReturnStatus);
}
} while (true);
}
} - 69/4
APPENDIX F
Methods For Accessing Card Operating System Capabilities In The Preferred
Embodiment
public class _OS {
static native byte SelectFile (short filejd); static native byte SelectParent 0; static native byte SelectCD 0; static native byte SelectRoot 0;
static native byte CreateFile (byte file idrfj); static native byte DeleteFile (short filejd);
// General File Manipulation static native byte ResetFile 0; static native byte ReadByte (byte offset); static native short ReadWord (byte offset);
// Header Manipulation static native byte GetFilelnfo (byte file_hdr[]);
// Binary File support static native byte ReadBinaryFile (short offset, byte datajength, byte bufferfj); static native byte WriteBinaryFile (short offset, byte datajength, byte bufferD);
// Record File support static native byte SelectRecord (byte recordjib, byte mode); static native byte NextRecord (); static native byte PreviousRecord (); - 69/5 -
static native byte ReadRecord (byte record_data[], byte recordjib, byte offset, byte length); static native byte WriteRecord (byte buffer[], byte recordjib, byte offset, byte length);
// Cyclic File Support static native byte LastUpdatedRec 0;
// Messaging Functions static native byte GetMessage (byte buffer[], byte expected Jength, byte ack_code); static native byte SendMessage (byte buffer[], byte datajength); static native byte SetSpeed (byte speed);
// Identity Management static native byte CheckAccess (byte ac_action); static native byte VerifyKey (byte key_number, byte key_buffer[], byte key Jength); static native byte VerifyCHV (byte CHVjiumber, byte CHV_buffer[], byte unblock_flag); static native byte ModifyCHV (byte CHVjiumber, byte old_CHV_buffer[], byte new_CHV_buffer[], byte unblock_flag); static native byte GetFileStatus 0; static native byte SetFileStatus (byte file_status);
static native byte GrantSupervisorMode (); static native byte RevokeSupervisorModeQ;
static native byte SetFileACL (byte file_acl[]); static native byte GetFileACL (byte file_acl[]);
// File context manipulation static native void InitFileStatus (); static native void BackupFileStatus (); static native void RestoreFileStatus ();
// Utilities static native byte CompareBuffer (byte pattern Jength, byte buffer_1[], byte buffer_2[]); static native short AvailableMemory (); static native void ResetCard (byte mode); static native byte SendATR (); static native byte SetDefaultATR (byte buffer[], byte length); static native byte Execute (short filejd, byte flag);
// Global state variable functions static native byte Getldentity (); static native byte GetRecordNb (); static native short GetApplicationld (); static native byte GetRecord Length (); static native byte GetFileType (); static native short GetFileLength (); static native void SendStatus (byte status); - 69/7 -
- 69/8 -
APPENDIX G
Byte Code Attributes Tables
Dividing Java byte codes into type groups
Each bytecode is assigned a 5 bit type associated with it. This is used to group the codes into similarly behaving sets. In general this behaviour reflects how the types of byte codes operate on the stack, but types 0, 13, 14, and 15 reflect specific kinds of instructions as denoted in the comments section.
The table below illustrates the state of the stack before and after each type of instruction is executed.
Tvpe Before execution After exececution Comment
0 Illegal instruction
1 stk0==int stk1 = -int pop(1)
2 stk0==int pop(1)
3 stk0==int stk1 = =int pop(2)
4 5 push(1)
6 stk0==int stk1 = =int pop(3)
7 stk0==int pop(1)
8 stk0==ref pop(1)
9 stk0==int pop(1)
10 push(1) stk0<-int
11 push(1) stk0<-ref
12 stk0==ref stk0<-int
13 DUPs, SWAP instructions
14 INVOKE instructions
15 FIELDS instructions
16 stk0<-ref - -
Using Standard Java Byte Code (without reordering) - Attribute Lookup Table
/*
* Table of bytecode decode information. This contains a bytecode type
* and a bytecode length. We currently support all standard bytecodes
* (ie. no quicks) which gives us codes 0 to 201 (202 codes in all). 7
#define T_ 0
#define T3 1
#define T6 2
#define T1 3
#define T2 4
#define T7 5
#define T9 6
#define T8 7
#define T12 8
#define T10 9
#define T5 10
#define T11 11
#define T16 12
#define T4 13
#define T13 14
#define T14 15
#define T15 16
#define D(T,L)
_BUILD_ITYPE_AND_ILENGTH(T, L)
#define _BUILD_ITYPE_ANDJLENGTH(T,L)
_BUILDJTYPE(T)|_BUILD_ILENGTH(L))
#define _BUILD_ITYPE(T) ((T) « 3)
#define _BUILDJLENGTH(L) (L)
#define _GET_ITYPE(I) ((I) & 0xF8)
#define _GET_ILENGTH(I) ((I) & 0x07) - 69/10
const uintδ SCODE _decodeinfo[256] = {
D(T4 1), NOP
D(T11 /* ACONST_NULL
D(T10 /* ICONST_M1
D(T10 /* ICONST_0
D(T10 /* ICONSTJ
D(T10 I* ICONST_2
D(T10 /* ICONSTJ3
D(T10 /* ICONST_4
D(T10 /* ICONST 5
D(T_
D(T_
D(T_
D(T_
D(T_
D(T_
D(T_
D(T10,2), /* BIPUSH 7
D(T10,3), /* SIPUSH 7
D(T_ ,2), /* LDC1 7
D(T11 ,3), r LDC2 7
D(T_ ,3),
D(T5 /* ILOAD D(T_ D(T_ D(T_ D(T5 /* ALOAD 7 D(T5 /*ILOAD_0 7 D(T5 /* ILOAD 7 D(T5 /*ILOAD_2 7 D(T5 /* ILOAD 3 7 D(T_ D(T_ D(T_ D(T_ - 69/11 -
/*ALOAD_07 ALOAD 7 /*ALOAD_27 /*ALOAD_3 7 /* IALOAD 7
AALOAD 7
/*BALOAD 7
ΛCALOAD 7 SALOAD 7 r ISTORE 7
/* ASTORE 7
/* ISTORE_0 7
/* ISTORE_1 7
/* ISTORE_2 7
Λ ISTORE 3 7
Figure imgf000081_0001
D(T_ 1 )
D(T_ 1 )
D(T_ 1 ).
D(T_ 1 ).
D(T_ )
D(T_ 1 )
D(T8 1 ) /* ASTORE_0 7
D(T8 i ) /* ASTORE 7
D(T8 i ) /* ASTORE_2 7
D(T8 1 ) /* ASTORE_3 7
D(T_ i ) ΛIASTORE 7
D(T_ 1 )
D(T_ 1 )
D(T_ 1 )
D(T_ 1 ) /* AASTORE 7
D(T6 i ) /* BASTORE 7
D(T_ i ) /* CASTORE 7
D(T6 1 ) /* SASTORE 7
D(T2 i ) /*POP 7
D(T3 1 ) /* POP2 7
D(T13, 1 ) /* DUP 7
D(T13, 1 ) /* DUP_X1 7
D(T13, 1 ) /* DUP_X2 7
D(T13, 1 ) r DUP2 7
D(T13, 1 ) /*DUP2_X1 7
D(T13, 1 ) /*DUP2_X2 7
D(T13, 1 ) r SWAP 7
D( T , 1 ) /* IADD 7
D(T_ , 1 )
D(T_ , 1 )
D(T1 , 1 )
D(T_ , 1 ) /* ISUB 7
D(T_ , 1 )
D(T_ , 1 )
D(T_ .1 ) - -
/* IMUL
r iDiv 7
Λ IREM
/* INEG
I* ISHL 7
/* ISHR
/* IUSHR 7
/* IAND
IOR 7
I* IXOR
/* IINC
Figure imgf000083_0001
- 69 14 -
/* INT2BYTE 7
/* INT2CHAR 7
/* INT2SHORT 7
/* IFEQ
/* IFNE
/* IFLT
/* IFGE
/* IFGT
/* IFLT
/* IFJCMPEQ
I* IFJCMPNE
I* IFJCMPLT
I* IFJCMPGE
I* IFJCMPGT
/* IFJCMPLE
/* IF_ACMPEQ
/* IF_ACMPNE GOTO
/* JSR
/* RET
/* TABLESWITCH *
/* LOOKUPSWITCH'
Λ IRETURN 7
Figure imgf000084_0001
D(T_ , 1 ).
D( T_ , 1 ),
D( T8 , 1 ), /* ARETURN 7
D( T4 , 1 ), /* RETURN 7
D(T15,3), /* GETSTATIC 7
D(T15,3), /* PUTSTATIC 7
D(T15,3), /* GETFIELD 7
D(T15,3), /* PUTFIELD 7
D(T14,3), /* INVOKEVIRTUAL 7
D(T14,3), /* INVOKESPECIAL 7
D(T14,3), /* INVOKESTATIC 7
D(T14,5), /* INVOKEINTERFACE 7
D( T_ , 1 ),
D(T11 ,3), /* NEW 7
D(T16,2), /* NEWARRAY 7
D( T_ ,3 ),
D(T12, 1 ), /* ARRAYLENGTH 7
D( T8 , 1 ), ATHROW 7
D(T16,3), /* CHECKCAST 7
D(T12,3), /* INSTANCEOF 7
D( T_ , 1 ),
D("T_ 1 )•
D(T_ 1 ).
D(T_ 4),
D(T8 3), /* IFNULL 7
D(T8 3), /* IFNONNULL 7
D(T_ 5),
D(T_ 5),
D(T_
D(T_
D(T_
D(T_
D(T_
D(T_
D(T_ - 69 16 -
Figure imgf000086_0001
- 69/17 -
Figure imgf000087_0001
};
- 69/18 -
APPENDIX H
Checks Done On Java Byte Codes By Type
Decoding the instruction. This gives us the length to generate the next PC, and the instruction type:
pcargl = _GET_ILENGTH _decodeinfo[insn]); itype = _GET_ITYPE(_decodeinfo[insn]);
Implement some pre-execution checks based on this:
/* Check the input stack state based on the instuction type 7 if (itype <= ITYPE9) { if (itype <= ITYPE1) { check_stack_int(1);
} check_stack_int(0);
} else if (itype <= ITYPE12) { check_stack_ref(0);
} else if (itype < ITYPE11) { push(1); }
Finally, implement some post execution checks:
/* Set the output state 7 if (itype <= ITYPE8) { if (itype <= ITYPE6) { if (itype >= ITYPE6) { pop(1);
} - 69/19 -
pop(1); } pop(i); } else if (itype <= ITYPE10) { set_stack_int(0);
} else if (itype >= ITYPE11 && itype <= ITYPE16) { set_stack_ref(0); }
_ _
APPENDIX I
Checks Done On Renumbered Java Byte Codes
Get the instruction. The numeric value of the instruction implicitly contains the instruction type:
insn = getpc(-1);
Implement some pre-execution checks based on this:
/*
* Check input stack state. By renumbering the byte codes we can
* perform the necessary security checks by testing if the value of the
* byte code (and hence the byte code) belongs to the correct group 7 if (insn <= TYPE9_END) { if (insn <= TYPE1_END) { check_stack_int(1);
} check_stackjnt(0);
} else if (insn <= TYPE12_END) { check_stack_ref(0);
} else if (insn <= TYPE11_END) { push(1) }
Finally, implement some post execution checks:
I* - 69/21 -
* Set output stack state. 7 if (insn <= TYPE8_END) { if (insn <= TYPE6_END) { if (insn >= TYPE6_START) { pop(1);
} pop(1);
} pop(i); } else if (insn <= TYPE10_END) { set_stackjnt(0);
} else if (insn >= TYPE11_START && insn <= TYPE16_END) { set_stack_ref(0); }
- 69 22- -
Reordering of supported Java byte codes by type
/* TYPE 3 7
#define s_POP2 0
#define sJFJCMPEQ 1
#defιne sJFJCMPNE 2
#defιne sJFJCMPLT 3
#define sJFJCMPGE 4
#define sJFJCMPGT 5
#define sJFJCMPLE 6
#define s_IF_ACMPEQ 7
#define s_IF_ACMPNE 8
/* TYPE 6 7
#defιne TYPE6_START 9
#define s_SASTORE 9
#define s_AASTORE 10
#define s BASTORE 11
#define TYPE6 END 12
/* TYPE 1 7
#define s_ IADD 13 #define s_ ISUB 14 #define s_ IMUL 15 #define s_ IDIV 16 #define s_ IREM 17 #define s_ ISHL 18 #define s_ ISHR 19 #define s_ IUSHR 20 #define s IAND 21 - 69/23 -
#define sJOR 22
#define sJXOR 23
#define TYPE1 END 23
/* TYPE 2 7
#deflne sJSTORE 24
#define s_POP 25
#define sJFEQ 26
#define s_IFNE 27
#define sJFLT 28
#define sJFGE 29
#define s_IFGT 30
#define s IFLE 31
#define sJTABLESWITCH 32 #define s_LOOKUPSWITCH 33 #define sJRETURN 34
I* TYPE 7 7
#define s_SALOAD 35 #define s_AALOAD 36 #define s_BALOAD 37
/* TYPE 9 7
#define sJNEG 39
#define s_INT2BYTE 40 #define s_INT2CHAR 41
#define TYPE9_END 41
/* TYPE 8 7 „„ „ _
- 69 24 -
#define s_ASTORE 42 #define s_ARETURN 43 #define s_ATHROW 44 #define sJFNULL 45 #define sJFNONNULL 46
#define TYPE8_END 46
/* TYPE 12 7
#define s_ARRAYLENGTH 47 #define sJNSTANCEOF 48
#define TYPE12_END 48
/* TYPE 10 7
#define s_SIPUSH 49
#define TYPE10_END 49
/* TYPE 5 7
#define sJLOAD 50
#define s_ALOAD 51
/* TYPE 11 7
#define TYPE11_START 52
#define s_ACONST_NULL 52 #define s_LDC2 53
#define s_JSR 54
#define s NEW 55 - 69/25 -
#define TYPE11_END 55
/* TYPE 16 7
#define s_NEWARRAY 56
#define s_CHECKCAST 57
#define TYPE16 END 57
/* TYPE 13 7
#define s_DUP 58
#defιne s_DUP_X1 59
#define s_DUP_X2 60
#define s_DUP2 61
#define s_DUP2_X1 62
#define s_DUP2_X2 63
#define s_SWAP 64
/* TYPE 14 7
#define sJNVOKEVIRTUAL 65 /* 01000001 7 #define sJNVOKENONVIRTUAL 66 /* 01000010 7 #define sJNVOKESTATIC 67 I* 01000011 7 #define sJNVOKEINTERFACE 68 /* 01000100 7
I* TYPE 15 7
#define s_GETSTATIC 69 #define s_PUTSTATIC 70
#define s_GETFIELD 71
#define s_PUTFIELD 72
/* TYPE 4 7 - 69/26 -
#define s_NOP 73
#define sJINC 74
#define s_GOTO 75
#defines RET 76
#defιnes RETURN 77

Claims

- 70 -What is claimed is:
1. An integrated circuit card for use with a terminal, comprising: a communicator configured to communicate with the terminal; a memory storing : an application having a high level programming language format, and an interpreter; and a processor coupled to the memory, the processor configured to use the interpreter to interpret the application for execution and to use the communicator to communicate with the terminal .
2. The integrated circuit card of claim 1, wherein the high level programming language format comprises a class file format.
3. The integrated circuit card of claim 1 wherein the processor comprises a microcontroller.
. The integrated circuit card of claim 1 wherein at least a portion of the memory is located in the processor.
5. The integrated circuit card of claim 1 wherein the high level programming language format comprises a Java programming language format. - 71 -
6. The integrated circuit card of claim 1, wherein the application has been processed from a second application having a string of characters, and the string of characters is represented in the first application by an identifier.
7. The integrated circuit card of claim 6, wherein the identifier comprises an integer.
8. The integrated circuit card of claim 1 wherein the processor is further configured to: receive a request from a requester to access an element of the card; after receipt of the request, interact with the requester to authenticate an identity of the requester; and based on the identity, selectively grant access to the element.
9. The integrated circuit card of claim 8, wherein the requester comprises the processor.
10. The integrated circuit card of claim 8, wherein the requester comprises the terminal.
11. The integrated circuit card of claim 8, wherein the element comprises the application stored in the memory, and once access is allowed, the requester is configured to use the application.
12. The integrated circuit card of claim 8, wherein - 72 -
the element comprises another application stored in the memory.
13. The integrated circuit card of claim 8, wherein the element includes data stored in the memory.
14. The integrated circuit card of claim 8 wherein the element comprises the communicator.
15. The integrated circuit card of claim 8, wherein the memory also stores an access control list for the element, the access control list furnishing an indication of types of access to be granted to the identity, the processor further configured to: based on the access control list, selectively grant specific types of access to the requester.
16. The integrated circuit card of claim 15 wherein the types of access include reading data.
17. The integrated circuit card of claim 15 wherein the types of access include writing data.
18. The integrated circuit card of claim 15 wherein the types of access include appending data.
19. The integrated circuit card of claim 15 wherein the types of access include creating data.
20. The integrated circuit card of claim 15 wherein the types of access include deleting data.
21. The integrated circuit card of claim 15 wherein the types of access include executing an application. - 73 -
22. The integrated circuit card of claim 1, wherein the application is one of a plurality of applications stored in the memory, the processor is further configured to: receive a request from a requester to access one of the plurality of applications; after receipt of the request, determine whether said one of the plurality of applications complies with a predetermined set of rules; and based on the determination, selectively grant access to the requester to said one of the plurality of applications .
23. The integrated circuit card of claim 22, wherein the predetermined rules provide a guide for determining whether said one of the plurality of applications accesses a predetermined region of the memory .
24. The integrated circuit card of claim 22, wherein the processor is further configured to: authenticate an identity of the requester; and grant access to said one of the plurality of applications based on the identity.
25. The integrated circuit card of claim 1, wherein the processor is further configured to: interact with the terminal via the communicator to authenticate an identity; and determine if the identity has been authenticated; and based on the determination, selectively allow communication between the terminal and the integrated circuit card. - 74 -
26. The integrated circuit card of claim 25, wherein the communicator and the terminal communicate via communication channels, the processor further configured to assign one of the communication channels to the identity when the processor allows the communication between the terminal and the integrated circuit card.
27. The integrated circuit card of claim 26, wherein the processor is further configured to: assign a session key to said one of the communication channels, and use the session key when the processor and the terminal communicate via said one of the communication channels .
28. The integrated circuit card of claim 1, wherein the terminal has a card reader and the communicator comprises a contact for communicating with the card reader.
29. The integrated circuit card of claim 1, wherein the terminal has a wireless communication device and the communictor a wireless transceiver for communicating with the wireless communication device.
30. The integrated circuit card of claim 1, wherein the terminal has a wireless communication device and the communicator comprises a wireless transmitter for communicating with the wireless communication device. - 75 -
31. A method for use with an integrated circuit card and a terminal, comprising: storing an interpreter and an application having a high level programming language format in a memory of the integrated circuit card; and using a processor of the integrated circuit card to use the interpreter to interpret the application for execution; and using a communicator of the card when communicating between the processor and the terminal.
32. The method of claim 31, wherein the high level programming language format comprises a class file format .
33. The method of claim 31, wherein the processor comprises a microcontroller.
34. The method of claim 31, wherein at least a portion of the memory is located in the processor.
35. The method of claim 31, wherein the high level programming language format comprises a Java programming language format.
36. The method of claim 1, wherein the application has been processed from a second application having a string of characters, further comprising : representing the string of characters in the first application by an identifier.
37. The method of claim 36, wherein the identifier includes an integer. - 76 -
38. The method of claim 31, further comprising: receiving a request from a requester to access an element of the card; after receipt of the request, interacting with the requester to authenticate an identity of the requester; and based on the identity, selectively granting access to the element .
39. The method of claim 38, wherein the requester comprises the processor.
40. The method of claim 38, wherein the requester comprises the terminal.
41. The method of claim 38, wherein the element comprises the application stored in the memory, further comprising: once access is allowed, using the application with the requester.
42. The method of claim 38, wherein the element comprises another application stored in the memory.
43. The method of claim 38, wherein the element includes data stored in the memory.
44. The method of claim 38, wherein the element comprises the communicator. - 77 -
45. The method of claim 38, wherein the memory also stores an access control list for the element, the access control list furnishing an indication of types of access to be granted to the identity, further comprising: based on the access control list, using the processor to selectively grant specific types of access to the requester.
46. The method of claim 45, wherein the types of access include reading data.
47. The method of claim 45, wherein the types of access include writing data.
48. The method of claim 45, wherein the types of access include appending data.
49. The method of claim 45, wherein the types of access include creating data.
50. The method of claim 45, wherein the types of access include deleting data.
51. The method of claim 45, wherein the types of access including executing an application.
- 78 -
52. The method of claim 31, wherein the application is one of a plurality of applications stored in the memory, further comprising: receiving a request from a requester to access one of the applications stored in the memory; upon receipt of the request, determining whether said one of the plurality of applications complies with a predetermined set of rules; and based on the determining, selectively granting access to the said one of the plurality of applications .
53. The method of claim 52, wherein the predetermined rules provide a guide for determining whether said one of the plurality of applications accesses a predetermined region of the memory.
54. The method of claim 52, further comprising: authenticating an indentity of the requester; and based on the indentity, granting access to said one of the plurality of applications.
55. The method of claim 31, further comprising: communicating with the terminal to authenticate an identity; determining if the identity has been authenticated; and based on the determining, selectively allowing communication between the terminal and the integrated circuit card. - 79 -
56. The method of claim 55, further comprising: communicating between the terminal and the processor via communication channels; and assigning one of the communication channels to the identity when the allowing allows communication between the card reader and the integrated circuit card.
57. The method of claim 56, further comprising: assigning a session key to said one of the communication channels; and using the session key when the processor and the terminal communicate via said one of the communication channels.
- 80 -
58. A smart card comprising: a memory storing a Java interpreter; and a processor configured to use the interpreter to interpret a Java application for execution.
59. A microcontroller comprising: a semiconductor substrate; a memory located in the substrate; a programming language interpreter stored in the memory and configured to implement security checks; and a central processing unit located in the substrate and coupled to the memory.
60. The microcontroller of claim 59, wherein the interpreter comprises a Java byte code interpreter.
61. The microcontroller of claim 59, wherein the security checks comprise establishing firewalls.
62. The microcontroller of claim 59, wherein the security checks comprise enforcing a sandbox security model .
63. A smart card comprising: a memory; a programming language interpreter stored in the memory and configured to implement security checks; and a central processing unit coupled to the memory .
64. The smart card of claim 63, wherein the interpreter comprises a Java byte code interpreter. - 81 -
65. The smart card of claim 63, wherein the security checks comprise establishing firewalls.
66. The smart card of claim 63, wherein the security checks comprise enforcing a sandbox security model .
67. An integrated circuit card for use with a terminal, comprising: a communicator; a memory storing an interpreter and first instructions of a first application, the first instructions having been converted from second instructions of a second application; and a processor coupled to the memory and configured to use the interpreter to execute the first instructions and to communicate with the terminal via the communicator .
68. The integrated circuit card of claim 67, wherein the first application has a class file format.
69. The integrated circuit card of claim 67, wherein the second application has a class file format.
70. The integrated circuit card of claim 67, wherein the first instructions comprise byte codes.
71. The integrated circuit card of claim 67, wherein the second instructions comprise byte codes.
72. The integrated circuit card of claim 67, wherein the first instructions comprise Java byte codes. - -
73. The integrated circuit card of claim 67, wherein the second instructions comprise Java byte codes.
74. The integrated circuit card of claim 67, wherein the first instructions comprise generalized versions of the second instructions.
75. The integrated circuit card of claim 67, wherein the first instructions comprise renumbered versions of the second instructions.
76. The integrated circuit card of claim 67, wherein the second instructions include constant references, and the first instructions include constants that replace the constant references of the second instructions.
77. The integrated circuit card of claim 67, wherein the second instructions include references, the references shifting location during the conversion of the second instructions to the first instructions, and the first instructions are relinked to the references after the shifting.
78. The integrated circuit card of claim 67, wherein the first instructions comprise byte codes for a first type of virtual machine, and the second instructions comprise byte codes for a second type of virtual machine, the first type being different from the second type. - 83 -
79. A method for use with an integrated circuit card, comprising: converting second instructions of a second application to first instructions of a first application; storing the first instructions in a memory of the integrated circuit card; and using an interpreter of the integrated circuit card to execute the first instructions.
80. The method of claim 79, wherein the first application has a class file format.
81. The method of claim 79, wherein the second application has a class file format.
82. The method of claim 79, wherein the first instructions comprise byte codes.
83. The method of claim 79, wherein the second instructions comprise byte codes.
84. The method of claim 79, wherein the first instructions comprise Java byte codes.
85. The method of claim 79, wherein the second instructions comprise Java byte codes.
86. The method of claim 79, wherein the first instructions are generalized versions of the second instructions .
87. The method of claim 79, wherein the converting includes renumbering the second instructions to form first instructions. - 84 -
88. The method of claim 79, wherein the second instructions include constant references, and the converting includes replacing the constant references of the second instructions with constants.
89. The method of claim 79, wherein the second instructions include references and the converting includes shifting location of the references, further comprising: relinking the first instructions to the references after the converting.
90. The method of claim 79, wherein the first instructions comprise byte codes for a first type of virtual machine, and the second instructions comprise byte codes for a second type of virtual machine, the first type being different from the second type.
- 85 -
91. An integrated circuit for use with a terminal, comprising: a communicator configured to communicate with the terminal ; a memory storing a first application that has been processed from a second application having a string of characters, the string of characters being represented in the first application by an identifier; and a processor coupled to the memory, the processor configured to use the interpreter to interpret the first application for execution and to use the communicator to communicate with the terminal .
92. The integrated circuit card of claim 91, wherein the identifier comprises an integer.
93. A method for use with an integrated circuit card and a terminal comprising: processing a second application to create a first application, the second application having a string of characters; representing the string of characters of the first application by an identifier in the second application; storing an interpreter and the first application in a memory of the integrated circuit card; and using a processor of the integrated circuit card to use an interpreter to interpret the first application for execution.
94. The method of claim 93, wherein the indentifier includes an integer. - 86 -
95. A microcontroller comprising: a memory storing: an application having a class file format , and an interpreter; and a processor coupled to the memory, the processor configured to use the interpreter to interpret the application for execution.
96. The microcontroller of claim 95, further comprising: a communicator configured to communicate with a terminal .
97. The microcontroller of claim 96, wherein' the terminal has a card reader and the communicator comprises a contact for communicating with the card reader.
98. The microcontroller of claim 96, wherein the terminal has a wireless communication device and the communictor a wireless transceiver for communicating with the wireless communication device.
99. The microcontroller of claim 96, wherein the terminal has a wireless communication device and the communicator comprises a wireless transmitter for communicating with the wireless communication device.
100. The microcontroller of claim 95, wherein the class file format comprises a Java class file format. - 87 -
101. A method for use with an integrated circuit card, comprising: storing a first application in a memory of the integrated circuit card; storing a second application in the memory of the integrated circuit card; and creating a firewall that isolates the first and second applications so that the second application cannot access either the first application or data associated with the first application.
102. The method of claim 101, wherein the first and second applications comprise Java byte codes.
103. The method of claim 100, wherein the creating includes using a Java interpreter.
104. The method of claim 101, wherein the storing of the first application is performed in association with manufacture of the integrated circuit card; and the storing of the second application is performed at a later time after the manufacture is completed.
- 88 -
105. An integrated circuit card for use with a terminal, comprising: a communicator configured to communicate with the terminal; a memory storing : applications, each application having a high level programming language format, and an interpreter; and a processor coupled to the memory, the processor configured to: a.) use the interpreter to interpret the applications for execution, b.) use the interpreter to create a firewall to isolate the applications from each other, and c.) use the communicator to communicate with the terminal .
PCT/US1997/018999 1996-10-25 1997-10-22 Using a high level programming language with a microcontroller WO1998019237A1 (en)

Priority Applications (6)

Application Number Priority Date Filing Date Title
JP10520562A JP2000514584A (en) 1996-10-25 1997-10-22 Microcontroller using high-level programming language
AU49118/97A AU722463B2 (en) 1996-10-25 1997-10-22 Using a high level programming language with a microcontroller
BR9713267-5A BR9713267A (en) 1996-10-25 1997-10-22 Integrated circuit card for use with a terminal, process for use with it, microcontroller and process for programming
DE69714752.5T DE69714752C5 (en) 1996-10-25 1997-10-22 USING A HIGH PROGRAMMING LANGUAGE IN A MICROCONTROLLER
EP97911833A EP0932865B1 (en) 1996-10-25 1997-10-22 Using a high level programming language with a microcontroller
HK00100664A HK1021762A1 (en) 1996-10-25 2000-02-03 Using a high level programming language with a microcontroller

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US2905796P 1996-10-25 1996-10-25
US60/029,057 1996-10-25

Publications (1)

Publication Number Publication Date
WO1998019237A1 true WO1998019237A1 (en) 1998-05-07

Family

ID=21846980

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US1997/018999 WO1998019237A1 (en) 1996-10-25 1997-10-22 Using a high level programming language with a microcontroller

Country Status (15)

Country Link
US (7) US6308317B1 (en)
EP (1) EP0932865B1 (en)
JP (2) JP2000514584A (en)
KR (1) KR100329063B1 (en)
CN (1) CN1183449C (en)
AU (1) AU722463B2 (en)
BR (1) BR9713267A (en)
DE (1) DE69714752C5 (en)
ES (1) ES2184066T3 (en)
HK (1) HK1021762A1 (en)
MY (1) MY126363A (en)
PT (1) PT932865E (en)
TW (1) TW476914B (en)
WO (1) WO1998019237A1 (en)
ZA (1) ZA979479B (en)

Cited By (89)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2000008611A1 (en) * 1998-08-06 2000-02-17 Visa International Service Association Terminal software architecture for use with smart cards
EP0992958A2 (en) * 1998-10-09 2000-04-12 Schlumberger Industries S.A. Metering device with programmable smart card
EP1006478A2 (en) * 1998-12-01 2000-06-07 Kabushiki Kaisha Toshiba IC card, portable device, and data updating method for IC card
WO2000043877A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using shared object interfaces
WO2000043878A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
WO2000043876A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using an entry point object
WO2000043875A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
WO2000045262A2 (en) * 1999-01-22 2000-08-03 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
WO2000045311A1 (en) * 1999-02-01 2000-08-03 Bluecell Ab A method and device for exchange of information
WO2000046664A2 (en) * 1999-02-05 2000-08-10 Cyrus Intersoft, Inc. Instrumenting streamed classes
WO2000049584A1 (en) * 1999-02-19 2000-08-24 Bull Cp8 On-board system comprising network interface means and method for activating applications located in said on-board system
WO2000068903A1 (en) * 1999-05-11 2000-11-16 Microsoft Corporation Smart card application development system and method
WO2000068902A1 (en) * 1999-05-11 2000-11-16 Microsoft Corporation Method and apparatus for sharing data files among runtime environment applets in an integrated circuit card
WO2000070566A1 (en) * 1999-05-19 2000-11-23 Brokat Infosystems Ag Input device for business transactions
US6157966A (en) * 1997-06-30 2000-12-05 Schlumberger Malco, Inc. System and method for an ISO7816 complaint smart card to become master over a terminal
EP1063585A2 (en) * 1999-06-23 2000-12-27 Sun Microsystems, Inc. Operation code encoding
EP1085395A2 (en) * 1999-09-13 2001-03-21 Phone.Com Inc. Access control system for files on a memory card
WO2001020899A1 (en) * 1999-09-15 2001-03-22 Koninklijke Philips Electronics N.V. Removable card system with downloadable agent program for communicating with a digital television receiver or other host device
WO2001031599A1 (en) * 1999-10-25 2001-05-03 Smartflash Limited Data storage and access systems
FR2801118A1 (en) * 1999-11-17 2001-05-18 Bull Cp8 METHOD FOR LOADING APPLICATIONS IN A MULTI-APPLICATION ONBOARD SYSTEM, CORRESPONDING ONBOARD SYSTEM, AND METHOD FOR EXECUTING AN ONBOARD SYSTEM APPLICATION
WO2001039464A1 (en) * 1999-11-19 2001-05-31 Swisscom Mobile Ag Adaptable chip card
WO2001042887A2 (en) * 1999-12-10 2001-06-14 Gemplus Access control for co-operating applications in a chip card
WO2001057810A1 (en) * 2000-02-03 2001-08-09 Gemplus Time management at communication level for a smart card-type entity
WO2001060040A2 (en) * 2000-02-10 2001-08-16 Bull Cp8 Method for data transmission on an internet-type network between a server and a smart card terminal, comprising intelligent agents
WO2001061486A2 (en) * 2000-02-17 2001-08-23 Interactive Video Technologies, Inc. Incremental bootstrap class loader
WO2001063385A1 (en) * 2000-02-21 2001-08-30 Ncipher Corporation Limited Controlling access to a resource by a program using a digital signature
JP2001283160A (en) * 2000-03-30 2001-10-12 Dainippon Printing Co Ltd Ic card and device and method for updating ic card
US6308270B1 (en) 1998-02-13 2001-10-23 Schlumberger Technologies, Inc. Validating and certifying execution of a software program with a smart card
US6308317B1 (en) 1996-10-25 2001-10-23 Schlumberger Technologies, Inc. Using a high level programming language with a microcontroller
FR2812101A1 (en) * 2000-07-24 2002-01-25 Bull Cp8 Protocol for exchange of messages between applications embedded in a multi-function smart card, uses transmission of calls from master application to cause operating system to load and execute slave application
JP2002117381A (en) * 2000-10-05 2002-04-19 Dainippon Printing Co Ltd Ic card
JP2002529849A (en) * 1998-11-06 2002-09-10 ブル・セー・ペー・8 Data compression method for intermediate object code program executable in embedded system supplied with data processing resources, and embedded system corresponding to this method and having multiple applications
WO2002076126A2 (en) * 2001-03-16 2002-09-26 Schlumberger Systèmes Subscriber identity module for managing a plurality of commands of at least one applet
JP2002536744A (en) * 1999-02-02 2002-10-29 サン・マイクロシステムズ・インコーポレーテッド Link step based on token
JP2002536743A (en) * 1999-02-02 2002-10-29 サン・マイクロシステムズ・インコーポレーテッド Object Oriented Instruction Set for Resource Constrained Devices
JP2003507811A (en) * 1999-08-23 2003-02-25 トラステ ロジク Protocol for managing downloaded program fragments, method for verifying and converting downloaded program fragments, and corresponding system
US6564995B1 (en) 1997-09-19 2003-05-20 Schlumberger Malco, Inc. Smart card application-selection
WO2002033866A3 (en) * 2000-10-20 2003-09-04 Trusted Logic Protocol for transmitting a plurality of multiple exchange logic flow of command/response pairs on a single physical exchange channel between master and slave and corresponding system for controlling and monitoring execution of applets
US6651186B1 (en) 2000-04-28 2003-11-18 Sun Microsystems, Inc. Remote incremental program verification using API definitions
US6675338B1 (en) 2000-08-09 2004-01-06 Sun Microsystems, Inc. Internally generated vectors for burnin system
US6694436B1 (en) 1998-05-22 2004-02-17 Activcard Terminal and system for performing secure electronic transactions
FR2846770A1 (en) * 2002-11-04 2004-05-07 Oberthur Card Syst Sa Microcircuit card for computer system, has card manager to communicate local code of local object reference obtained from previous reference upon reception of message having logical identifier of computer object
US6769053B1 (en) 1999-06-10 2004-07-27 Belle Gate Investment B.V. Arrangement storing different versions of a set of data in separate memory areas and method for updating a set of data in a memory
US6845498B1 (en) 1999-05-11 2005-01-18 Microsoft Corporation Method and apparatus for sharing data files among run time environment applets in an integrated circuit card
US6883163B1 (en) 2000-04-28 2005-04-19 Sun Microsystems, Inc. Populating resource-constrained devices with content verified using API definitions
US6883716B1 (en) 1999-12-07 2005-04-26 Sun Microsystems, Inc. Secure photo carrying identification device, as well as means and method for authenticating such an identification device
EP1537516A2 (en) * 2002-08-02 2005-06-08 Cardtronic Method and system for executing applications on a mobile device
WO2005055052A2 (en) * 2003-12-08 2005-06-16 Giesecke & Devrient Gmbh Java smart card chip comprising a memory area reserved for global variables
US6912633B2 (en) 2002-03-18 2005-06-28 Sun Microsystems, Inc. Enhanced memory management for portable devices
US6938244B1 (en) 1999-05-11 2005-08-30 Microsoft Corp. Interlaced protocol for smart card application development
EP1580663A1 (en) * 2002-11-13 2005-09-28 Netac Technology Co., Ltd. A method for realizing security data storage and algorithm storage by means of semiconductor memory device
US6981245B1 (en) 2000-09-14 2005-12-27 Sun Microsystems, Inc. Populating binary compatible resource-constrained devices with content verified using API definitions
US6986132B1 (en) 2000-04-28 2006-01-10 Sun Microsytems, Inc. Remote incremental program binary compatibility verification using API definitions
US6996802B2 (en) 2002-03-18 2006-02-07 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using initialization order and calling order constraints
US6996213B1 (en) 1998-09-29 2006-02-07 Sun Microsystems, Inc. Superposition of data over voice
US7010783B2 (en) 2002-03-18 2006-03-07 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using reduced dynamic memory allocation
WO2006024904A1 (en) * 2004-08-30 2006-03-09 Axalto Sa Data access security implementation using the public key mechanism
US7020740B2 (en) 1999-12-06 2006-03-28 Sun Microsystems, Inc. Computer arrangement using non-refreshed DRAM
US7080261B1 (en) 1999-12-07 2006-07-18 Sun Microsystems, Inc. Computer-readable medium with microprocessor to control reading and computer arranged to communicate with such a medium
US7085840B2 (en) 2001-10-29 2006-08-01 Sun Microsystems, Inc. Enhanced quality of identification in a data communications network
USRE39269E1 (en) 1994-02-08 2006-09-05 Sun Microsystems, Inc. Data exchange system comprising portable data processing units
US7140549B2 (en) 2004-02-24 2006-11-28 Sun Microsystems, Inc. Method and apparatus for selecting a desired application on a smart card
US7158993B1 (en) 1999-11-12 2007-01-02 Sun Microsystems, Inc. API representation enabling submerged hierarchy
US7165246B2 (en) 2003-01-16 2007-01-16 Sun Microsystems, Inc. Optimized representation of data type information in program verification
US7165727B2 (en) 2004-02-24 2007-01-23 Sun Microsystems, Inc. Method and apparatus for installing an application onto a smart card
US7181737B2 (en) 2002-03-18 2007-02-20 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using static procedure return addresses
US7191288B2 (en) 2004-02-24 2007-03-13 Sun Microsystems, Inc. Method and apparatus for providing an application on a smart card
US7191434B2 (en) 1999-09-14 2007-03-13 Tao Group Limited Loading object-oriented computer programs
US7222331B2 (en) 2003-01-16 2007-05-22 Sun Microsystems, Inc. Linking of virtual methods
WO2007091162A1 (en) * 2006-02-10 2007-08-16 Nokia Corporation Improved mobile communication terminal
US7272830B2 (en) 2003-01-16 2007-09-18 Sun Microsystems, Inc. Ordering program data for loading on a device
US7275260B2 (en) 2001-10-29 2007-09-25 Sun Microsystems, Inc. Enhanced privacy protection in identification in a data communications network
US7281244B2 (en) 2003-01-16 2007-10-09 Sun Microsystems, Inc. Using a digital fingerprint to commit loaded data in a device
EP1860589A1 (en) * 2006-05-26 2007-11-28 Incard SA Method for accessing structured data in IC Cards
CN100357848C (en) * 2003-01-16 2007-12-26 太阳微系统公司 Signing program data payload in program loading
US7374099B2 (en) 2004-02-24 2008-05-20 Sun Microsystems, Inc. Method and apparatus for processing an application identifier from a smart card
US7484095B2 (en) 2003-01-16 2009-01-27 Sun Microsystems, Inc. System for communicating program data between a first device and a second device
US7571436B2 (en) 2003-04-01 2009-08-04 Panasonic Corporation Device for increasing the execution speed of a linked program
US7636749B2 (en) 1999-05-19 2009-12-22 Ricoh Company, Ltd. System for distributing, installing and running web applications (agents)
US7874492B2 (en) 2001-12-04 2011-01-25 Visa U.S.A. Inc. Method and system for facilitating memory and application management on a secured token
US7908216B1 (en) 1999-07-22 2011-03-15 Visa International Service Association Internet payment, authentication and loading system using virtual smart card
WO2011085960A1 (en) * 2010-01-13 2011-07-21 Giesecke & Devrient Gmbh Method for providing a secure counter on a terminal
US8027920B1 (en) 1999-11-10 2011-09-27 Mei, Inc. Value transaction systems
WO2011123532A1 (en) * 2010-03-30 2011-10-06 Qualcomm Incorporated Methods and apparatus for device applet management on smart cards
EP2535832A1 (en) * 2011-06-17 2012-12-19 Simulity Labs Ltd A method for operating a virtual machine over a file system
US8548923B2 (en) 2002-10-07 2013-10-01 Sonia Reed Method and system for facilitating data access and management on a secure token
CN102984706B (en) * 2003-12-23 2016-05-04 法国电信公司 Comprise two telecommunication terminals of carrying out space
US10732977B2 (en) 2017-06-16 2020-08-04 Seoul National University R&Db Foundation Bytecode processing device and operation method thereof
EP3913516A4 (en) * 2019-03-22 2022-04-13 Huawei Technologies Co., Ltd. File access authority authentication method and electronic device

Families Citing this family (200)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0825506B1 (en) 1996-08-20 2013-03-06 Invensys Systems, Inc. Methods and apparatus for remote process control
GB2337434B (en) * 1997-03-14 2002-01-30 Ian Charles Ogilvy Method and apparatus for controlling communications
DK0992025T3 (en) 1997-06-27 2002-10-28 Swisscom Mobile Ag Transaction method with a portable identification element
US6230006B1 (en) 1997-09-08 2001-05-08 Acterna, Llc Test system for remotely testing switches within a telecommunications network
US6736325B1 (en) * 1998-01-22 2004-05-18 Mondex International Limited Codelets
CN1109971C (en) * 1998-03-23 2003-05-28 国际商业机器公司 JAVA runtime system with modified constant pool
US7020441B2 (en) * 1998-09-03 2006-03-28 Casabyte, Inc. Test system for remotely testing switches within a telecommunications network
US7139915B2 (en) * 1998-10-26 2006-11-21 Microsoft Corporation Method and apparatus for authenticating an open system application to a portable IC device
US7174457B1 (en) * 1999-03-10 2007-02-06 Microsoft Corporation System and method for authenticating an operating system to a central processing unit, providing the CPU/OS with secure storage, and authenticating the CPU/OS to a third party
US6609199B1 (en) * 1998-10-26 2003-08-19 Microsoft Corporation Method and apparatus for authenticating an open system application to a portable IC device
US7194092B1 (en) * 1998-10-26 2007-03-20 Microsoft Corporation Key-based secure storage
US20050060549A1 (en) * 1998-10-26 2005-03-17 Microsoft Corporation Controlling access to content based on certificates and access predicates
ATE287557T1 (en) * 1998-11-03 2005-02-15 Thomson Licensing Sa METHOD AND APPARATUS FOR COMPUTER CODE UPDATE USING AN INTERFACE TO AN INTEGRATED CIRCUIT
US6425003B1 (en) * 1999-01-22 2002-07-23 Cisco Technology, Inc. Method and apparatus for DNS resolution
US6581206B2 (en) * 1999-11-12 2003-06-17 Sun Microsystems, Inc. Computer program language subset validation
US6848111B1 (en) 1999-02-02 2005-01-25 Sun Microsystems, Inc. Zero overhead exception handling
US7127605B1 (en) * 1999-05-10 2006-10-24 Axalto, Inc. Secure sharing of application methods on a microcontroller
US7089530B1 (en) 1999-05-17 2006-08-08 Invensys Systems, Inc. Process control configuration system with connection validation and configuration
WO2000070531A2 (en) 1999-05-17 2000-11-23 The Foxboro Company Methods and apparatus for control configuration
US6546546B1 (en) * 1999-05-19 2003-04-08 International Business Machines Corporation Integrating operating systems and run-time systems
FR2794543B1 (en) * 1999-06-04 2001-08-24 Gemplus Card Int MIGRATION OF DIFFERENT SOURCE LANGUAGES TO EXECUTION MEDIA
US6788980B1 (en) * 1999-06-11 2004-09-07 Invensys Systems, Inc. Methods and apparatus for control using control devices that provide a virtual machine environment and that communicate via an IP network
FR2795835B1 (en) * 1999-07-01 2001-10-05 Bull Cp8 METHOD FOR VERIFYING CODE TRANSFORMERS FOR AN ON-BOARD SYSTEM, ESPECIALLY ON A CHIP CARD
US6684389B1 (en) * 1999-08-05 2004-01-27 Canon Kabushiki Kaisha Compiler that decrypts encrypted source code
US7376583B1 (en) 1999-08-10 2008-05-20 Gofigure, L.L.C. Device for making a transaction via a communications link
EP1206741A1 (en) * 1999-08-11 2002-05-22 Spinware, Inc. System and method for controlling access to data stored in a portable storage medium
US6560774B1 (en) * 1999-09-01 2003-05-06 Microsoft Corporation Verifier to check intermediate language
AU1223901A (en) * 1999-10-20 2001-04-30 Spyrus, Inc. Method and system for an integrated circuit card interface device with multiple modes of operation
US6363523B1 (en) * 1999-11-12 2002-03-26 Sun Microsystems, Inc. Optimization of N-base typed arithmetic expressions
US7107581B2 (en) * 1999-11-12 2006-09-12 Sun Microsystems, Inc. Overflow predictive arithmetic instruction optimization using chaining
US8453133B2 (en) * 1999-11-12 2013-05-28 Oracle America, Inc. Optimization of N-base typed arithmetic instructions via rework
US7207037B2 (en) * 1999-11-12 2007-04-17 Sun Microsystems, Inc. Overflow sensitive arithmetic instruction optimization using chaining
US7010786B2 (en) 1999-11-12 2006-03-07 Sun Microsystems, Inc. Predictive arithmetic overflow detection
US6757824B1 (en) * 1999-12-10 2004-06-29 Microsoft Corporation Client-side boot domains and boot rules
US20010007146A1 (en) * 1999-12-23 2001-07-05 Uwe Hansmann Method for providing a set of software components
US6748592B1 (en) * 2000-02-14 2004-06-08 Xoucin, Inc. Method and apparatus for protectively operating a data/information processing device
US6813762B1 (en) * 2000-02-22 2004-11-02 Freescale Semiconductor, Inc. Method for processing program files in a programming language capable of dynamic loading
JP2002091762A (en) * 2000-09-14 2002-03-29 Denso Corp Program generator
US8176296B2 (en) 2000-10-26 2012-05-08 Cypress Semiconductor Corporation Programmable microcontroller architecture
US6724220B1 (en) 2000-10-26 2004-04-20 Cyress Semiconductor Corporation Programmable microcontroller architecture (mixed analog/digital)
US7765095B1 (en) 2000-10-26 2010-07-27 Cypress Semiconductor Corporation Conditional branching in an in-circuit emulation system
US8103496B1 (en) 2000-10-26 2012-01-24 Cypress Semicondutor Corporation Breakpoint control in an in-circuit emulation system
US8149048B1 (en) 2000-10-26 2012-04-03 Cypress Semiconductor Corporation Apparatus and method for programmable power management in a programmable analog circuit block
US20020108054A1 (en) * 2001-02-02 2002-08-08 Moore Christopher S. Solid-state memory device storing program code and methods for use therewith
CN1227626C (en) * 2001-02-08 2005-11-16 诺基亚有限公司 Smart card reader
US7080373B2 (en) * 2001-03-07 2006-07-18 Freescale Semiconductor, Inc. Method and device for creating and using pre-internalized program files
US6971001B1 (en) * 2001-05-17 2005-11-29 Accenture Global Services Gmbh General and reusable components for defining net-centric application program architectures
AU2006200734B2 (en) * 2001-05-17 2007-12-13 Accenture Global Services Limited Pipeline architecture for use with net-centric application program architectures
US20040218762A1 (en) 2003-04-29 2004-11-04 Eric Le Saint Universal secure messaging for cryptographic modules
US8209753B2 (en) * 2001-06-15 2012-06-26 Activcard, Inc. Universal secure messaging for remote security tokens
US7921287B2 (en) * 2001-08-13 2011-04-05 Qualcomm Incorporated Application level access privilege to a storage area on a computer device
US7155702B2 (en) * 2001-09-13 2006-12-26 Axalto Sa Interface and stub generation for code distribution and synthesis
US7406674B1 (en) 2001-10-24 2008-07-29 Cypress Semiconductor Corporation Method and apparatus for generating microcontroller configuration information
US20030084302A1 (en) * 2001-10-29 2003-05-01 Sun Microsystems, Inc., A Delaware Corporation Portability and privacy with data communications network browsing
US7496751B2 (en) * 2001-10-29 2009-02-24 Sun Microsystems, Inc. Privacy and identification in a data communications network
JP4055393B2 (en) * 2001-10-30 2008-03-05 ソニー株式会社 Data processing apparatus and method and program thereof
US8078970B1 (en) 2001-11-09 2011-12-13 Cypress Semiconductor Corporation Graphical user interface with user-selectable list-box
US8042093B1 (en) 2001-11-15 2011-10-18 Cypress Semiconductor Corporation System providing automatic source code generation for personalization and parameterization of user modules
US7770113B1 (en) 2001-11-19 2010-08-03 Cypress Semiconductor Corporation System and method for dynamically generating a configuration datasheet
US7774190B1 (en) 2001-11-19 2010-08-10 Cypress Semiconductor Corporation Sleep and stall in an in-circuit emulation system
US6971004B1 (en) 2001-11-19 2005-11-29 Cypress Semiconductor Corp. System and method of dynamically reconfiguring a programmable integrated circuit
US8069405B1 (en) 2001-11-19 2011-11-29 Cypress Semiconductor Corporation User interface for efficiently browsing an electronic document using data-driven tabs
US7844437B1 (en) 2001-11-19 2010-11-30 Cypress Semiconductor Corporation System and method for performing next placements and pruning of disallowed placements for programming an integrated circuit
WO2003058446A1 (en) * 2002-01-11 2003-07-17 Sierra Wireless, Inc. Host extensible wireless application interface
US20100174717A1 (en) * 2002-02-28 2010-07-08 Olivier Fambon Interative serialisation procedure for structured software objects
DE60210416T2 (en) * 2002-02-28 2006-09-07 Matsushita Electric Industrial Co., Ltd., Kadoma memory card
US8769517B2 (en) * 2002-03-15 2014-07-01 International Business Machines Corporation Generating a common symbol table for symbols of independent applications
US8103497B1 (en) 2002-03-28 2012-01-24 Cypress Semiconductor Corporation External interface for event architecture
DE10216602A1 (en) * 2002-04-15 2003-10-30 Giesecke & Devrient Gmbh Optimization of compiler generated program code
US7890771B2 (en) 2002-04-17 2011-02-15 Microsoft Corporation Saving and retrieving data based on public key encryption
US7308608B1 (en) 2002-05-01 2007-12-11 Cypress Semiconductor Corporation Reconfigurable testing system and method
US6836670B2 (en) * 2002-05-09 2004-12-28 Casabyte, Inc. Method, apparatus and article to remotely associate wireless communications devices with subscriber identities and /or proxy wireless communications devices
FR2840084A1 (en) * 2002-05-27 2003-11-28 Gemplus Card Int Code verification method for limited resource microcircuits used especially for high security applications e.g. bank cards, or telecommunications, involves modification of intermediary code and verifying the reallocated code
NO20023194D0 (en) * 2002-07-01 2002-07-01 Sospita As Method and apparatus for executing software applications in a multiprocessor environment
US7761845B1 (en) 2002-09-09 2010-07-20 Cypress Semiconductor Corporation Method for parameterizing a user module
US20060064458A1 (en) * 2002-09-16 2006-03-23 Christian Gehrmann Secure access to a subscription module
EP1398934B1 (en) 2002-09-16 2008-01-02 Telefonaktiebolaget LM Ericsson (publ) Secure access to a subscription module
US6904591B2 (en) * 2002-11-01 2005-06-07 Oz Development, Inc. Software development system for editable executables
US20040123152A1 (en) * 2002-12-18 2004-06-24 Eric Le Saint Uniform framework for security tokens
US20040143739A1 (en) * 2003-01-16 2004-07-22 Sun Mircosystems, Inc., A Delaware Corporation Run time code integrity checks
US20040199787A1 (en) * 2003-04-02 2004-10-07 Sun Microsystems, Inc., A Delaware Corporation Card device resource access control
US20040221174A1 (en) * 2003-04-29 2004-11-04 Eric Le Saint Uniform modular framework for a host computer system
US7328432B2 (en) * 2003-06-02 2008-02-05 Sun Microsystems, Inc. Proximity-based addressing for supporting in-place execution in virtual machines
US7184756B2 (en) * 2003-06-12 2007-02-27 Motorola Inc. Wireless communication device with tamper resistant configuration settings
WO2005007258A1 (en) * 2003-07-23 2005-01-27 Koninklijke Philips Electronics N.V. Device to process program codes
US10437964B2 (en) * 2003-10-24 2019-10-08 Microsoft Technology Licensing, Llc Programming interface for licensing
CH716409B1 (en) * 2003-11-12 2021-01-29 Legic Identsystems Ag Method for writing a data organization in identification media and for writing and executing applications in the data organization.
US7907935B2 (en) * 2003-12-22 2011-03-15 Activcard Ireland, Limited Intelligent remote device
US20050138380A1 (en) * 2003-12-22 2005-06-23 Fedronic Dominique L.J. Entry control system
US7259696B1 (en) * 2004-02-10 2007-08-21 Zilog, Inc. Interactive web-based codeset selection and development tool
US7227492B1 (en) * 2004-02-10 2007-06-05 Zilog, Inc. Interpreting a common script block to output various forms of data according to a common protocol
US7362256B1 (en) * 2004-02-10 2008-04-22 Zilog, Inc. Loading a machine code API onto an 8-bit virtual machine to enable new functionality
US7436345B1 (en) * 2004-02-10 2008-10-14 Zilog, Inc. Script instruction for jumping to a location, interpreting a predetermined number of instructions and then jumping back
US7091857B2 (en) * 2004-02-12 2006-08-15 Mi-Jack Products, Inc. Electronic control system used in security system for cargo trailers
EP1728156A2 (en) * 2004-03-04 2006-12-06 Axalto SA A secure sharing of resources between applications in independent execution environments in a retrievable token (e.g smart card)
US7295049B1 (en) 2004-03-25 2007-11-13 Cypress Semiconductor Corporation Method and circuit for rapid alignment of signals
US20050263596A1 (en) * 2004-05-12 2005-12-01 Solicore, Inc. Portable charger, including portable sleeve, for an electronically readable card
US20060041854A1 (en) * 2004-07-22 2006-02-23 Steven Schlanger Devices and methods for programming microcontrollers
US8069436B2 (en) * 2004-08-13 2011-11-29 Cypress Semiconductor Corporation Providing hardware independence to automate code generation of processing device firmware
US8286125B2 (en) * 2004-08-13 2012-10-09 Cypress Semiconductor Corporation Model for a hardware device-independent method of defining embedded firmware for programmable systems
US7855672B1 (en) 2004-08-19 2010-12-21 Ixys Ch Gmbh Compressed codeset database format for remote control devices
KR100597413B1 (en) 2004-09-24 2006-07-05 삼성전자주식회사 Method for translating Java bytecode and Java interpreter using the same
US20060080655A1 (en) * 2004-10-09 2006-04-13 Axalto Inc. System and method for post-issuance code update employing embedded native code
FR2877454B1 (en) * 2004-11-04 2006-12-29 Gemplus Sa METHOD FOR LOADING AN OBJECT-ORIENTED INTERMEDIATE LANGUAGE CODE IN A PORTABLE DEVICE
US7232073B1 (en) 2004-12-21 2007-06-19 Sun Microsystems, Inc. Smart card with multiple applications
JP4215037B2 (en) * 2004-12-27 2009-01-28 セイコーエプソン株式会社 Resource management system, printer, printer network card, resource management program, and resource management method
JP4207938B2 (en) * 2005-02-01 2009-01-14 セイコーエプソン株式会社 Software authentication system, software authentication program, and software authentication method
JP2006244451A (en) * 2005-02-01 2006-09-14 Seiko Epson Corp Resource management system, resource management program, and resource management method
US7332976B1 (en) 2005-02-04 2008-02-19 Cypress Semiconductor Corporation Poly-phase frequency synthesis oscillator
JP4311386B2 (en) * 2005-02-14 2009-08-12 セイコーエプソン株式会社 File operation restriction system, file operation restriction program, file operation restriction method, electronic apparatus, and printing apparatus
EP1864236A1 (en) * 2005-02-17 2007-12-12 Acterna, LLC Methods and apparatuses to remotely test communications networks using digital fingerprints of content
JP4628149B2 (en) * 2005-03-14 2011-02-09 株式会社エヌ・ティ・ティ・ドコモ Access control apparatus and access control method
JP4232767B2 (en) * 2005-03-14 2009-03-04 セイコーエプソン株式会社 Software authentication system, software authentication program, and software authentication method
DE102005019753A1 (en) * 2005-04-28 2006-11-09 Braun Gmbh Sphygmomanometer and chip card for this
US7400183B1 (en) 2005-05-05 2008-07-15 Cypress Semiconductor Corporation Voltage controlled oscillator delay cell and method
US8089461B2 (en) 2005-06-23 2012-01-03 Cypress Semiconductor Corporation Touch wake for electronic devices
US8887295B2 (en) * 2005-06-27 2014-11-11 Safend Ltd. Method and system for enabling enterprises to use detachable memory devices that contain data and executable files in controlled and secure way
US7792289B2 (en) * 2005-06-28 2010-09-07 Mark Ellery Ogram Encrypted communications
US7698703B2 (en) * 2005-06-29 2010-04-13 Gemalto Inc. Imparting digital uniqueness to the types of a programming language using a unique digital sequence
US20070143601A1 (en) * 2005-12-15 2007-06-21 Arroyo Diana J System and method for authorizing information flows
US7647630B2 (en) * 2005-12-15 2010-01-12 International Business Machines Corporation Associating security information with information objects in a data processing system
DE102005061659A1 (en) * 2005-12-22 2007-06-28 Giesecke & Devrient Gmbh Secure a portable disk against attacks
FR2895608B1 (en) * 2005-12-23 2008-03-21 Trusted Logic Sa METHOD FOR MAKING A SECURED COUNTER ON AN ON-BOARD COMPUTER SYSTEM HAVING A CHIP CARD
JP4933292B2 (en) * 2006-02-28 2012-05-16 キヤノン株式会社 Information processing apparatus, wireless communication method, storage medium, program
US8067948B2 (en) 2006-03-27 2011-11-29 Cypress Semiconductor Corporation Input/output multiplexer bus
US20080052770A1 (en) * 2006-03-31 2008-02-28 Axalto Inc Method and system of providing security services using a secure device
US9092635B2 (en) 2006-03-31 2015-07-28 Gemalto Sa Method and system of providing security services using a secure device
DE102006023436A1 (en) * 2006-05-18 2007-11-22 Giesecke & Devrient Gmbh Authentication for remote function calls
EP1881404A1 (en) * 2006-07-20 2008-01-23 Gemplus Method for dynamic protection of data during intermediate language software execution in a digital device
US7817799B2 (en) * 2006-09-07 2010-10-19 International Business Machines Corporation Maintaining encryption key integrity
EP1936574A1 (en) * 2006-12-01 2008-06-25 Cassis International PTE Ltd. CAP file for the personalisation of a Java application
US7971061B2 (en) * 2006-12-11 2011-06-28 Pitney Bowes Inc. E-mail system and method having certified opt-in capabilities
US8285329B1 (en) 2007-04-02 2012-10-09 Sprint Communications Company L.P. Mobile device-based control of smart card operation
US8092083B2 (en) 2007-04-17 2012-01-10 Cypress Semiconductor Corporation Temperature sensor with digital bandgap
US8516025B2 (en) 2007-04-17 2013-08-20 Cypress Semiconductor Corporation Clock driven dynamic datapath chaining
US7737724B2 (en) * 2007-04-17 2010-06-15 Cypress Semiconductor Corporation Universal digital block interconnection and channel routing
US8026739B2 (en) 2007-04-17 2011-09-27 Cypress Semiconductor Corporation System level interconnect with programmable switching
US8130025B2 (en) 2007-04-17 2012-03-06 Cypress Semiconductor Corporation Numerical band gap
US9564902B2 (en) 2007-04-17 2017-02-07 Cypress Semiconductor Corporation Dynamically configurable and re-configurable data path
US8040266B2 (en) 2007-04-17 2011-10-18 Cypress Semiconductor Corporation Programmable sigma-delta analog-to-digital converter
US8266575B1 (en) 2007-04-25 2012-09-11 Cypress Semiconductor Corporation Systems and methods for dynamically reconfiguring a programmable system on a chip
US9720805B1 (en) 2007-04-25 2017-08-01 Cypress Semiconductor Corporation System and method for controlling a target device
US8065653B1 (en) 2007-04-25 2011-11-22 Cypress Semiconductor Corporation Configuration of programmable IC design elements
ITMI20070996A1 (en) 2007-05-17 2008-11-18 Incard Sa METHOD FOR CHECKING THE EXECUTION OF AN APPLICATION FOR AN IC CARD
US8049569B1 (en) 2007-09-05 2011-11-01 Cypress Semiconductor Corporation Circuit and method for improving the accuracy of a crystal-less oscillator having dual-frequency modes
US8249654B1 (en) * 2007-09-27 2012-08-21 Sprint Communications Company L.P. Dynamic smart card application loading
US9883381B1 (en) 2007-10-02 2018-01-30 Sprint Communications Company L.P. Providing secure access to smart card applications
JP5262089B2 (en) * 2007-11-30 2013-08-14 凸版印刷株式会社 Computer apparatus mounted on IC card and processing method thereof
CN101520733B (en) * 2008-02-27 2014-04-16 国际商业机器公司 Method and device for class loading and method for reorganizing class archived file
CN101256612B (en) * 2008-04-01 2010-11-03 北京飞天诚信科技有限公司 Program protection method and system based on .Net card
CN101419549B (en) * 2008-05-13 2012-04-18 飞天诚信科技股份有限公司 Method for searching genus and function based on .Net card and the .Net card
CN104407518B (en) 2008-06-20 2017-05-31 因文西斯系统公司 The system and method interacted to the reality and Simulation Facility for process control
US8806457B2 (en) * 2008-12-15 2014-08-12 Apple Inc. Deferred constant pool generation
US20100211591A1 (en) * 2009-02-16 2010-08-19 Chuan-Hua Chang Apparatus for processing strings simultaneously
US9448964B2 (en) 2009-05-04 2016-09-20 Cypress Semiconductor Corporation Autonomous control in a programmable system
US8127060B2 (en) 2009-05-29 2012-02-28 Invensys Systems, Inc Methods and apparatus for control configuration with control objects that are fieldbus protocol-aware
US8463964B2 (en) 2009-05-29 2013-06-11 Invensys Systems, Inc. Methods and apparatus for control configuration with enhanced change-tracking
US9384063B2 (en) * 2009-06-18 2016-07-05 Microsoft Technology Licensing, Llc Eliding synchronization in a concurrent data structure
JP5449905B2 (en) * 2009-07-29 2014-03-19 フェリカネットワークス株式会社 Information processing apparatus, program, and information processing system
KR101345414B1 (en) * 2009-11-05 2013-12-27 트러스티드 로직 secure portable object
KR101054596B1 (en) * 2009-11-18 2011-08-04 에스케이씨앤씨 주식회사 Memory saving method using Java Card Migrator
US8276188B2 (en) * 2009-12-03 2012-09-25 Condel International Technologies Inc. Systems and methods for managing storage devices
US10305910B2 (en) * 2010-01-15 2019-05-28 Apple Inc. Accessing specialized fileserver
EP2397998A1 (en) * 2010-06-17 2011-12-21 Gemalto SA Method and system for controlling the processing of a plurality of radio frequency communication streams by a chip card
US8732670B1 (en) 2010-06-29 2014-05-20 Ca, Inc. Ensuring determinism during programmatic replay in a virtual machine
US8769518B1 (en) 2010-06-29 2014-07-01 Ca, Inc. Ensuring determinism during programmatic replay in a virtual machine
US8499299B1 (en) 2010-06-29 2013-07-30 Ca, Inc. Ensuring deterministic thread context switching in virtual machine applications
US8959492B2 (en) * 2010-12-14 2015-02-17 Ngmoco, Llc Communication protocol between a high-level language and a native language
US8646059B1 (en) 2010-12-17 2014-02-04 Google Inc. Wallet application for interacting with a secure element application without a trusted server for authentication
US8352749B2 (en) * 2010-12-17 2013-01-08 Google Inc. Local trusted services manager for a contactless smart card
US8621168B2 (en) 2010-12-17 2013-12-31 Google Inc. Partitioning the namespace of a contactless smart card
US8533336B1 (en) * 2011-02-04 2013-09-10 Google Inc. Automated web frontend sharding
JP5329602B2 (en) * 2011-05-12 2013-10-30 株式会社三菱東京Ufj銀行 Terminal device and program
US8255687B1 (en) 2011-09-15 2012-08-28 Google Inc. Enabling users to select between secure service providers using a key escrow service
US8171525B1 (en) 2011-09-15 2012-05-01 Google Inc. Enabling users to select between secure service providers using a central trusted service manager
US8313036B1 (en) 2011-09-16 2012-11-20 Google Inc. Secure application directory
US9544759B2 (en) 2011-11-01 2017-01-10 Google Inc. Systems, methods, and computer program products for managing states
KR101826275B1 (en) 2011-11-01 2018-02-06 구글 엘엘씨 Systems, methods, and computer program products for interfacing multiple service provider trusted service managers and secure elements
JP5818695B2 (en) * 2012-01-04 2015-11-18 インターナショナル・ビジネス・マシーンズ・コーポレーションInternational Business Machines Corporation Code conversion method, program and system
WO2013111490A1 (en) * 2012-01-25 2013-08-01 ソニー株式会社 Information processing apparatus, information processing method, and computer program
US8385553B1 (en) 2012-02-28 2013-02-26 Google Inc. Portable secure element
JP5953867B2 (en) * 2012-03-26 2016-07-20 富士ゼロックス株式会社 Program and program protection device
ITMI20120561A1 (en) * 2012-04-05 2013-10-06 St Microelectronics Srl METHOD TO PROTECT AN APPLICATION PROGRAM
US8429409B1 (en) 2012-04-06 2013-04-23 Google Inc. Secure reset of personal and service provider information on mobile devices
US20130311382A1 (en) * 2012-05-21 2013-11-21 Klaus S. Fosmark Obtaining information for a payment transaction
US9383448B2 (en) 2012-07-05 2016-07-05 Deca System Co., Ltd. Golf GPS device with automatic hole recognition and playing hole selection
US8676709B2 (en) 2012-07-31 2014-03-18 Google Inc. Merchant category codes in a proxy card transaction
WO2014047069A1 (en) 2012-09-18 2014-03-27 Jvl Ventures, Llc Systems, methods, and computer program products for interfacing multiple service provider trusted service managers and secure elements
CN104182267B (en) * 2013-05-21 2019-10-25 南京中兴新软件有限责任公司 Compilation Method, means of interpretation, device and user equipment
EP2843605A1 (en) * 2013-08-30 2015-03-04 Gemalto SA Method for authenticating transactions
US9516006B2 (en) * 2013-10-23 2016-12-06 Google Inc. Re-programmable secure cryptographic device
US9280339B1 (en) * 2013-12-12 2016-03-08 Amazon Technologies, Inc. Class replacer during application installation
AU2015343181B2 (en) * 2014-11-05 2017-06-01 Tabor Mountain Llc Remote control of fire suppression systems
US10176094B2 (en) 2015-06-30 2019-01-08 Renesas Electronics America Inc. Common MCU self-identification information
US10466977B2 (en) 2015-10-11 2019-11-05 Renesas Electronics America Inc. Data driven embedded application building and configuration
JP6275098B2 (en) * 2015-10-16 2018-02-07 三菱電機株式会社 Control device and register failure recovery method
WO2017209876A1 (en) * 2016-05-31 2017-12-07 Brocade Communications Systems, Inc. Buffer manager
CN109840395A (en) * 2017-11-24 2019-06-04 航天信息股份有限公司 A kind of method and system based on Java card downloading application program
US10698666B2 (en) * 2017-12-29 2020-06-30 Microsoft Technology Licensing, Llc Automatically building software projects
CN108966235B (en) * 2018-06-20 2021-07-02 融慧金科金融服务外包(北京)有限公司 Running method of IOS user network identity card RHIDFA

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR2667171A1 (en) * 1990-09-25 1992-03-27 Gemplus Card Int Portable support with easily programmable microcircuit and method of programming this microcircuit
WO1996025724A1 (en) * 1995-02-17 1996-08-22 Europay International S.A. Integrated circuit controlled transaction management system

Family Cites Families (104)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE408455C (en) 1923-07-15 1925-01-19 Georg Koenig Process for the continuous determination of the calorific value of gas mixtures
FR2386080A1 (en) 1977-03-31 1978-10-27 Cii Honeywell Bull ACCOUNTING SYSTEM FOR PREDETERMINED HOMOGENEOUS UNITS
US4650975A (en) * 1984-08-30 1987-03-17 Casio Computer Co., Ltd. IC card and an identification system thereof
US4667290A (en) * 1984-09-10 1987-05-19 501 Philon, Inc. Compilers using a universal intermediate language
JPS61204741A (en) 1985-03-06 1986-09-10 Nec Corp Compressing method for source program
JPH0635227B2 (en) 1985-07-31 1994-05-11 トツパン・ム−ア株式会社 IC card having means for reading update information and history information
US4905138A (en) * 1985-10-17 1990-02-27 Westinghouse Electric Corp. Meta-interpreter
US4874935A (en) * 1986-03-10 1989-10-17 Data Card Coprporation Smart card apparatus and method of programming same
GB2191029B (en) 1986-05-29 1990-12-12 Almex Systems Ltd Electronic pass
JPH07104891B2 (en) 1986-08-05 1995-11-13 沖電気工業株式会社 Transaction processor
US5133072A (en) * 1986-11-13 1992-07-21 Hewlett-Packard Company Method for improved code generation in reduced instruction set computers
JPS63156254A (en) 1986-12-19 1988-06-29 Fujitsu Ltd Control method for intermediate text by interpreter
JPS63156255A (en) 1986-12-19 1988-06-29 Fujitsu Ltd Overlaying method by interpreter
DE3743639A1 (en) 1986-12-24 1988-07-07 Mitsubishi Electric Corp IC CARD AND SYSTEM FOR CHECKING ITS FUNCTIONALITY
US4791558A (en) * 1987-02-13 1988-12-13 International Business Machines Corporation System and method for generating an object module in a first format and then converting the first format into a format which is loadable into a selected computer
JPS63231692A (en) * 1987-03-20 1988-09-27 Mitsubishi Electric Corp Secret code writer
FR2626095B1 (en) * 1988-01-20 1991-08-30 Sgs Thomson Microelectronics SECURITY SYSTEM FOR PROTECTING PROGRAMMING AREAS OF A CHIP CARD
US4892974A (en) 1988-03-10 1990-01-09 Air Products And Chemicals, Inc. Process for producing mono-ortho-tert-butyl-aniline using silica-alumina catalysts
JPH01243125A (en) * 1988-03-24 1989-09-27 Fuji Electric Co Ltd Method for improving execution speed of interpreter program
US5195130A (en) 1988-05-05 1993-03-16 Transaction Technology, Inc. Computer and telephone apparatus with user friendly computer interface and enhanced integrity features
JP2666847B2 (en) * 1988-06-06 1997-10-22 日本電気株式会社 Heterogeneous language communication method
US5313614A (en) 1988-12-06 1994-05-17 At&T Bell Laboratories Method and apparatus for direct conversion of programs in object code form between different hardware architecture computer systems
US5119465A (en) * 1989-06-19 1992-06-02 Digital Equipment Corporation System for selectively converting plurality of source data structures through corresponding source intermediate structures, and target intermediate structures into selected target structure
JPH0378082A (en) 1989-08-21 1991-04-03 Hitachi Ltd Reservation transaction processing method
CA2025170A1 (en) * 1989-09-28 1991-03-29 John W. White Portable and dynamic distributed applications architecture
US5120939A (en) 1989-11-09 1992-06-09 At&T Bell Laboratories Databaseless security system
US5339419A (en) * 1990-06-25 1994-08-16 Hewlett-Packard Company ANDF compiler using the HPcode-plus compiler intermediate language
US5450575A (en) * 1991-03-07 1995-09-12 Digital Equipment Corporation Use of stack depth to identify machine code mistakes
US5307492A (en) * 1991-03-07 1994-04-26 Digital Equipment Corporation Mapping assembly language argument list references in translating code for different machine architectures
JP3602857B2 (en) * 1991-04-23 2004-12-15 株式会社日立製作所 Multi-model compatible information processing system and method
JP2690229B2 (en) 1991-11-26 1997-12-10 三菱電機株式会社 Non-contact IC card
US5406380A (en) 1991-12-30 1995-04-11 Management Graphics, Inc. Film recorder with interface for user replaceable memory element
EP0706692B1 (en) * 1992-10-26 2003-04-16 Intellect Australia Pty. Ltd. Host and user transaction system
US5469572A (en) * 1992-12-01 1995-11-21 Taylor; James M. Post compile optimizer for linkable object code
US5367685A (en) * 1992-12-22 1994-11-22 Firstperson, Inc. Method and apparatus for resolving data references in generated code
FR2705810B1 (en) 1993-05-26 1995-06-30 Gemplus Card Int Chip card chip provided with a means of limiting the number of authentications.
US5519866A (en) * 1993-06-28 1996-05-21 Taligent, Inc. Method and apparatus of incrementally linking components of a modeled computer program
EP0711441A1 (en) 1993-07-30 1996-05-15 Intellect Australia Pty. Ltd. Device and method for ic cards
US5650761A (en) 1993-10-06 1997-07-22 Gomm; R. Greg Cash alternative transaction system
GB2283349A (en) 1993-10-29 1995-05-03 Ibm Transaction processing system
FR2713803B1 (en) * 1993-12-07 1996-01-12 Gemplus Card Int Memory card and operating method.
US5457799A (en) * 1994-03-01 1995-10-10 Digital Equipment Corporation Optimizer for program loops
US5537474A (en) * 1994-07-29 1996-07-16 Motorola, Inc. Method and apparatus for authentication in a communication system
US5500517A (en) * 1994-09-02 1996-03-19 Gemplus Card International Apparatus and method for data transfer between stand alone integrated circuit smart card terminal and remote computer of system operator
US5732270A (en) 1994-09-15 1998-03-24 Visual Edge Software Limited System and method for providing interoperability among heterogeneous object systems
US5544086A (en) 1994-09-30 1996-08-06 Electronic Payment Services, Inc. Information consolidation within a transaction network
US5841866A (en) * 1994-09-30 1998-11-24 Microchip Technology Incorporated Secure token integrated circuit and method of performing a secure authentication function or transaction
US5613120A (en) * 1994-10-20 1997-03-18 Silicon Graphics, Inc. System and method for enabling, without recompilation, modification of class definitions and implementations in an object-oriented computer program
US5613012A (en) 1994-11-28 1997-03-18 Smarttouch, Llc. Tokenless identification system for authorization of electronic transactions and electronic transmissions
US5748964A (en) * 1994-12-20 1998-05-05 Sun Microsystems, Inc. Bytecode program interpreter apparatus and method with pre-verification of data type restrictions
US5668999A (en) * 1994-12-20 1997-09-16 Sun Microsystems, Inc. System and method for pre-verification of stack usage in bytecode program loops
US5590331A (en) * 1994-12-23 1996-12-31 Sun Microsystems, Inc. Method and apparatus for generating platform-standard object files containing machine-independent code
US5679945A (en) * 1995-03-31 1997-10-21 Cybermark, L.L.C. Intelligent card reader having emulation features
US5590197A (en) * 1995-04-04 1996-12-31 V-One Corporation Electronic payment system and method
DE19518930A1 (en) 1995-05-23 1996-11-28 Siemens Ag Connection control method for interactive services
JP3310525B2 (en) * 1995-06-01 2002-08-05 ビー・イー・テクノロジー株式会社 Digital data processing device
US6181867B1 (en) * 1995-06-07 2001-01-30 Intervu, Inc. Video storage and retrieval system
US5692132A (en) 1995-06-07 1997-11-25 Mastercard International, Inc. System and method for conducting cashless transactions on a computer network
US5689565A (en) 1995-06-29 1997-11-18 Microsoft Corporation Cryptography system and method for providing cryptographic services for a computer application
US5675804A (en) * 1995-08-31 1997-10-07 International Business Machines Corporation System and method for enabling a compiled computer program to invoke an interpretive computer program
US5663553A (en) * 1995-09-27 1997-09-02 Intel Corporation Mass storage device adapter for smart cards
DE19536169A1 (en) * 1995-09-29 1997-04-03 Ibm Multifunctional chip card
CA2160496A1 (en) 1995-10-13 1997-04-14 Allan M. Brown Electronic funds acceptor for vending machines
CA2236586A1 (en) 1995-12-01 1997-06-05 Lsi Logic Corporation Integrated network browser chip, network browser system, and method for network data communication
US6151618A (en) * 1995-12-04 2000-11-21 Microsoft Corporation Safe general purpose virtual machine computing system
US6526565B1 (en) * 1995-12-21 2003-02-25 International Business Machines Corporation Packaging algorithm for providing object oriented applications having reduced footprints
FR2742892B1 (en) * 1995-12-21 1998-02-13 Bull Sa SOFTWARE PROTECTION SYSTEM FOR A WRITTEN LANGUAGE COMPUTER
US5835772A (en) * 1995-12-29 1998-11-10 Intel Corporation Method and apparatus for providing an interface between a system and a peripheral device
US5811771A (en) 1996-05-22 1998-09-22 Dethloff; Juergen Method and system for paying with a portable data medium having security against over charging and unauthorized use
US6535903B2 (en) * 1996-01-29 2003-03-18 Compaq Information Technologies Group, L.P. Method and apparatus for maintaining translated routine stack in a binary translation environment
US6226789B1 (en) * 1996-01-29 2001-05-01 Compaq Computer Corporation Method and apparatus for data flow analysis
US5860008A (en) * 1996-02-02 1999-01-12 Apple Computer, Inc. Method and apparatus for decompiling a compiled interpretive code
US5742756A (en) * 1996-02-12 1998-04-21 Microsoft Corporation System and method of using smart cards to perform security-critical operations requiring user authorization
TW369753B (en) * 1996-02-14 1999-09-11 Mitsubishi Electric Corp Data security method and system
US5761306A (en) 1996-02-22 1998-06-02 Visa International Service Association Key replacement in a public key cryptosystem
US6075863A (en) * 1996-02-28 2000-06-13 Encanto Networks Intelligent communication device
US5848274A (en) * 1996-02-29 1998-12-08 Supercede, Inc. Incremental byte code compilation system
US5764989A (en) * 1996-02-29 1998-06-09 Supercede, Inc. Interactive software development system
JPH09244904A (en) * 1996-03-12 1997-09-19 Matsushita Electric Ind Co Ltd Virtual code translation system and virtual machine system
US5889941A (en) * 1996-04-15 1999-03-30 Ubiq Inc. System and apparatus for smart card personalization
US5915226A (en) * 1996-04-19 1999-06-22 Gemplus Card International Prepaid smart card in a GSM based wireless telephone network and method for operating prepaid cards
US5815657A (en) * 1996-04-26 1998-09-29 Verifone, Inc. System, method and article of manufacture for network electronic authorization utilizing an authorization instrument
US6151703A (en) * 1996-05-20 2000-11-21 Inprise Corporation Development system with methods for just-in-time compilation of programs
US5794049A (en) * 1996-06-05 1998-08-11 Sun Microsystems, Inc. Computer system and method for executing architecture specific code with reduced run-time memory space requirements
US5946487A (en) * 1996-06-10 1999-08-31 Lsi Logic Corporation Object-oriented multi-media architecture
GB9613450D0 (en) 1996-06-27 1996-08-28 Europay Int Sa Payment system
US5844218A (en) * 1996-07-16 1998-12-01 Transaction Technology, Inc. Method and system for using an application programmable smart card for financial transactions in multiple countries
US5923884A (en) * 1996-08-30 1999-07-13 Gemplus S.C.A. System and method for loading applications onto a smart card
EP0829828A1 (en) 1996-09-13 1998-03-18 Koninklijke KPN N.V. Multiple tickets in smart cards
US5875335A (en) 1996-09-30 1999-02-23 Apple Computer, Inc. Parameter marshaling techniques for dynamic object-oriented programming languages
US6438573B1 (en) * 1996-10-09 2002-08-20 Iowa State University Research Foundation, Inc. Real-time programming method
US6094528A (en) * 1996-10-24 2000-07-25 Sun Microsystems, Inc. Method and apparatus for system building with a transactional interpreter
CN1183449C (en) * 1996-10-25 2005-01-05 施卢默格系统公司 using a high level programming language with a microcontroller
US5905895A (en) * 1997-03-07 1999-05-18 International Business Machines Corporation Method and system for optimizing non-native bytecodes before bytecode interpretation
US5966536A (en) * 1997-05-28 1999-10-12 Sun Microsystems, Inc. Method and apparatus for generating an optimized target executable computer program using an optimized source executable
US6055211A (en) 1997-07-03 2000-04-25 Microchip Technology Incorporated Force page zero paging scheme for microcontrollers using data random access memory
US6078744A (en) * 1997-08-01 2000-06-20 Sun Microsystems Method and apparatus for improving compiler performance during subsequent compilations of a source program
US5987256A (en) * 1997-09-03 1999-11-16 Enreach Technology, Inc. System and process for object rendering on thin client platforms
US6233733B1 (en) * 1997-09-30 2001-05-15 Sun Microsystems, Inc. Method for generating a Java bytecode data flow graph
US6061520A (en) * 1998-04-07 2000-05-09 Sun Microsystems, Inc. Method and system for performing static initialization
US8127121B2 (en) * 1999-01-28 2012-02-28 Ati Technologies Ulc Apparatus for executing programs for a first computer architechture on a computer of a second architechture
US6880155B2 (en) * 1999-02-02 2005-04-12 Sun Microsystems, Inc. Token-based linking
US9086931B2 (en) * 2002-11-20 2015-07-21 Purenative Software Corporation System for translating diverse programming languages
US20080282238A1 (en) * 2007-05-10 2008-11-13 Microsoft Corporation Static type for late binding

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR2667171A1 (en) * 1990-09-25 1992-03-27 Gemplus Card Int Portable support with easily programmable microcircuit and method of programming this microcircuit
WO1996025724A1 (en) * 1995-02-17 1996-08-22 Europay International S.A. Integrated circuit controlled transaction management system

Cited By (178)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
USRE39269E1 (en) 1994-02-08 2006-09-05 Sun Microsystems, Inc. Data exchange system comprising portable data processing units
US6308317B1 (en) 1996-10-25 2001-10-23 Schlumberger Technologies, Inc. Using a high level programming language with a microcontroller
US9400668B2 (en) 1996-10-25 2016-07-26 Gemalto Sa Computer program product containing instructions for providing a processor the capability of executing an application derived from a compiled form
US8881119B2 (en) 1996-10-25 2014-11-04 Gemalto Sa Computer program product containing instructions for providing a processor the capability of executing an application derived from a compiled form
US8881118B2 (en) 1996-10-25 2014-11-04 Gemalto Sa Computer program product containing instructions for providing a processor the capability of executing an application derived from a compiled form
US8726247B2 (en) 1996-10-25 2014-05-13 Gemalto Sa Computer program product containing instructions for providing a processor the capability of executing an application derived from a compiled form
US6157966A (en) * 1997-06-30 2000-12-05 Schlumberger Malco, Inc. System and method for an ISO7816 complaint smart card to become master over a terminal
US6564995B1 (en) 1997-09-19 2003-05-20 Schlumberger Malco, Inc. Smart card application-selection
US6308270B1 (en) 1998-02-13 2001-10-23 Schlumberger Technologies, Inc. Validating and certifying execution of a software program with a smart card
US6694436B1 (en) 1998-05-22 2004-02-17 Activcard Terminal and system for performing secure electronic transactions
US6808111B2 (en) 1998-08-06 2004-10-26 Visa International Service Association Terminal software architecture for use with smart cards
WO2000008611A1 (en) * 1998-08-06 2000-02-17 Visa International Service Association Terminal software architecture for use with smart cards
US6996213B1 (en) 1998-09-29 2006-02-07 Sun Microsystems, Inc. Superposition of data over voice
EP0992958A2 (en) * 1998-10-09 2000-04-12 Schlumberger Industries S.A. Metering device with programmable smart card
US6591229B1 (en) 1998-10-09 2003-07-08 Schlumberger Industries, Sa Metrology device with programmable smart card
EP0992958A3 (en) * 1998-10-09 2002-06-19 Schlumberger Industries S.A. Metering device with programmable smart card
JP2002529849A (en) * 1998-11-06 2002-09-10 ブル・セー・ペー・8 Data compression method for intermediate object code program executable in embedded system supplied with data processing resources, and embedded system corresponding to this method and having multiple applications
EP1006478A3 (en) * 1998-12-01 2001-02-28 Kabushiki Kaisha Toshiba IC card, portable device, and data updating method for IC card
EP1006478A2 (en) * 1998-12-01 2000-06-07 Kabushiki Kaisha Toshiba IC card, portable device, and data updating method for IC card
CN100353324C (en) * 1999-01-22 2007-12-05 太阳微系统公司 Techniques for permitting access across a context barrier in a small footprint device using shared object interfaces
US6823520B1 (en) 1999-01-22 2004-11-23 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
US6907608B1 (en) 1999-01-22 2005-06-14 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
AU772045B2 (en) * 1999-01-22 2004-04-08 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
WO2000043877A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using shared object interfaces
EP1434121A3 (en) * 1999-01-22 2006-04-12 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
JP2013030176A (en) * 1999-01-22 2013-02-07 Oracle America Inc Techniques for permitting access across context barrier on small area device using input point object
JP2013030175A (en) * 1999-01-22 2013-02-07 Oracle America Inc Techniques for permitting access across context barrier on small area device using run-time environment privilege
JP4996787B2 (en) * 1999-01-22 2012-08-08 オラクル・アメリカ・インコーポレイテッド Security technology using context barrier in small area equipment
JP4981210B2 (en) * 1999-01-22 2012-07-18 オラクル・アメリカ・インコーポレイテッド Technology that allows access across context barriers using a shared object interface on small devices
WO2000043878A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
AU771765B2 (en) * 1999-01-22 2004-04-01 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
EP1445699A3 (en) * 1999-01-22 2006-11-15 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
US7607175B2 (en) 1999-01-22 2009-10-20 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using an entry point object
AU771623B2 (en) * 1999-01-22 2004-04-01 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using an entry point object
US7478389B2 (en) 1999-01-22 2009-01-13 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
WO2000045262A3 (en) * 1999-01-22 2001-01-25 Sun Microsystems Inc Techniques for permitting access across a context barrier in a small footprint device using global data structures
EP1434121A2 (en) * 1999-01-22 2004-06-30 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
CN100447745C (en) * 1999-01-22 2008-12-31 太阳微系统公司 Techniques for permitting access across a context barrier on a small footprint device using on entry point object
WO2000043876A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using an entry point object
WO2000043875A1 (en) * 1999-01-22 2000-07-27 Sun Microsystems, Inc. Techniques for implementing security on a small footprint device using a context barrier
US7395535B2 (en) 1999-01-22 2008-07-01 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
US6922835B1 (en) 1999-01-22 2005-07-26 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
KR100687668B1 (en) * 1999-01-22 2007-02-28 썬 마이크로시스템즈, 인코포레이티드 Techniques for permitting access across a context barrier in a small footprint device using global data structures
KR100688397B1 (en) * 1999-01-22 2007-03-09 썬 마이크로시스템즈, 인코포레이티드 Techniques for permitting access across a context barrier on a small footprint device using an entry point object
US6633984B2 (en) 1999-01-22 2003-10-14 Sun Microsystems, Inc. Techniques for permitting access across a context barrier on a small footprint device using an entry point object
KR100688396B1 (en) * 1999-01-22 2007-03-09 썬 마이크로시스템즈, 인코포레이티드 Techniques for implementing security on a small footprint device using a context barrier
CN1316360C (en) * 1999-01-22 2007-05-16 太阳微系统公司 Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
AU773772B2 (en) * 1999-01-22 2004-06-03 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using shared object interfaces
AU763958B2 (en) * 1999-01-22 2003-08-07 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
KR100716699B1 (en) * 1999-01-22 2007-05-14 썬 마이크로시스템즈, 인코포레이티드 Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
WO2000045262A2 (en) * 1999-01-22 2000-08-03 Sun Microsystems, Inc. Techniques for permitting access across a context barrier in a small footprint device using global data structures
WO2000045311A1 (en) * 1999-02-01 2000-08-03 Bluecell Ab A method and device for exchange of information
EP1145107B1 (en) * 1999-02-02 2006-10-18 Sun Microsystems, Inc. Token-based linking
JP2002536743A (en) * 1999-02-02 2002-10-29 サン・マイクロシステムズ・インコーポレーテッド Object Oriented Instruction Set for Resource Constrained Devices
JP2002536744A (en) * 1999-02-02 2002-10-29 サン・マイクロシステムズ・インコーポレーテッド Link step based on token
CN1324467C (en) * 1999-02-02 2007-07-04 太阳微电子公司 Token-based linking
US7444631B2 (en) 1999-02-02 2008-10-28 Sun Microsystems, Inc. Token-based linking
US6880155B2 (en) 1999-02-02 2005-04-12 Sun Microsystems, Inc. Token-based linking
AU771699B2 (en) * 1999-02-02 2004-04-01 Sun Microsystems, Inc. Token-based linking
WO2000046664A2 (en) * 1999-02-05 2000-08-10 Cyrus Intersoft, Inc. Instrumenting streamed classes
WO2000046664A3 (en) * 1999-02-05 2000-12-07 Cyrus Intersoft Inc Instrumenting streamed classes
AU775230B2 (en) * 1999-02-19 2004-07-22 Cp8 Technologies On-board system comprising network interface means and method for activating applications located in said on-board system
WO2000049584A1 (en) * 1999-02-19 2000-08-24 Bull Cp8 On-board system comprising network interface means and method for activating applications located in said on-board system
FR2790629A1 (en) * 1999-02-19 2000-09-08 Bull Cp8 METHOD FOR ACTIVATING LOCALIZED APPLICATIONS IN A CHIP CARD BY A BROWSER OF THE TYPE SAID "WEB"
US6839756B1 (en) 1999-02-19 2005-01-04 Bull Cp8 On board system comprising network interface means, and method for activating applications located in said on-board system
WO2000068902A1 (en) * 1999-05-11 2000-11-16 Microsoft Corporation Method and apparatus for sharing data files among runtime environment applets in an integrated circuit card
US7703086B2 (en) 1999-05-11 2010-04-20 Microsoft Corporation Method and apparatus for sharing data files among runtime environment applets in an integrated circuit card
US6547150B1 (en) 1999-05-11 2003-04-15 Microsoft Corporation Smart card application development system and method
US6938244B1 (en) 1999-05-11 2005-08-30 Microsoft Corp. Interlaced protocol for smart card application development
US6845498B1 (en) 1999-05-11 2005-01-18 Microsoft Corporation Method and apparatus for sharing data files among run time environment applets in an integrated circuit card
US7454741B2 (en) 1999-05-11 2008-11-18 Microsoft Corporation Method and apparatus for sharing data files among runtime environment applets in an integrated circuit card
WO2000068903A1 (en) * 1999-05-11 2000-11-16 Microsoft Corporation Smart card application development system and method
US7516444B2 (en) 1999-05-11 2009-04-07 Microsoft Corporation Interlaced protocol for smart card application development
US7636749B2 (en) 1999-05-19 2009-12-22 Ricoh Company, Ltd. System for distributing, installing and running web applications (agents)
WO2000070566A1 (en) * 1999-05-19 2000-11-23 Brokat Infosystems Ag Input device for business transactions
US6769053B1 (en) 1999-06-10 2004-07-27 Belle Gate Investment B.V. Arrangement storing different versions of a set of data in separate memory areas and method for updating a set of data in a memory
EP1063585A3 (en) * 1999-06-23 2003-08-20 Sun Microsystems, Inc. Operation code encoding
EP1063585A2 (en) * 1999-06-23 2000-12-27 Sun Microsystems, Inc. Operation code encoding
US7908216B1 (en) 1999-07-22 2011-03-15 Visa International Service Association Internet payment, authentication and loading system using virtual smart card
US8533116B2 (en) 1999-07-22 2013-09-10 Visa International Service Association Internet payment, authentication and loading system using virtual smart card
JP2003507811A (en) * 1999-08-23 2003-02-25 トラステ ロジク Protocol for managing downloaded program fragments, method for verifying and converting downloaded program fragments, and corresponding system
EP1085395A3 (en) * 1999-09-13 2002-09-11 Phone.Com Inc. Access control system for files on a memory card
EP1085395A2 (en) * 1999-09-13 2001-03-21 Phone.Com Inc. Access control system for files on a memory card
US7191434B2 (en) 1999-09-14 2007-03-13 Tao Group Limited Loading object-oriented computer programs
WO2001020899A1 (en) * 1999-09-15 2001-03-22 Koninklijke Philips Electronics N.V. Removable card system with downloadable agent program for communicating with a digital television receiver or other host device
US7334720B2 (en) 1999-10-25 2008-02-26 Smart-Flash Limited Data storage and access systems
WO2001031599A1 (en) * 1999-10-25 2001-05-03 Smartflash Limited Data storage and access systems
US8033458B2 (en) 1999-10-25 2011-10-11 Smartflash Technologies Limited Data storage and access systems
US8794516B2 (en) 1999-10-25 2014-08-05 Smartflash, LLC Data storage and access systems
JP2014115995A (en) * 1999-10-25 2014-06-26 Smartflash Technologies Ltd Data storage and access system
US8118221B2 (en) 1999-10-25 2012-02-21 Smartflash Technologies Limited Data storage and access systems
US8336772B2 (en) 1999-10-25 2012-12-25 Smartflash Technologies Limited Data storage and access systems
US9471910B2 (en) 1999-10-25 2016-10-18 Smartflash, LLC Data storage and access systems
US7942317B2 (en) 1999-10-25 2011-05-17 Smartflash Technologies Limited Data storage and access systems
US8061598B2 (en) 1999-10-25 2011-11-22 Smartflash Technologies Limited Data storage and access systems
US8027920B1 (en) 1999-11-10 2011-09-27 Mei, Inc. Value transaction systems
US7158993B1 (en) 1999-11-12 2007-01-02 Sun Microsystems, Inc. API representation enabling submerged hierarchy
US6983460B1 (en) 1999-11-17 2006-01-03 Cp8 Technologies Method for loading applications into a multiapplication embedded system equipped with data processing resources, corresponding embedded system and execution method
WO2001037085A1 (en) * 1999-11-17 2001-05-25 Bull Cp8 Method for loading applications in a multiapplication onplatform system equipped with data processing resources, corresponding executing system and method
FR2801118A1 (en) * 1999-11-17 2001-05-18 Bull Cp8 METHOD FOR LOADING APPLICATIONS IN A MULTI-APPLICATION ONBOARD SYSTEM, CORRESPONDING ONBOARD SYSTEM, AND METHOD FOR EXECUTING AN ONBOARD SYSTEM APPLICATION
WO2001039464A1 (en) * 1999-11-19 2001-05-31 Swisscom Mobile Ag Adaptable chip card
US6847831B2 (en) 1999-11-19 2005-01-25 Swisscom Mobile Ag Adaptable chip card
US7020740B2 (en) 1999-12-06 2006-03-28 Sun Microsystems, Inc. Computer arrangement using non-refreshed DRAM
US7080261B1 (en) 1999-12-07 2006-07-18 Sun Microsystems, Inc. Computer-readable medium with microprocessor to control reading and computer arranged to communicate with such a medium
US6883716B1 (en) 1999-12-07 2005-04-26 Sun Microsystems, Inc. Secure photo carrying identification device, as well as means and method for authenticating such an identification device
WO2001042887A2 (en) * 1999-12-10 2001-06-14 Gemplus Access control for co-operating applications in a chip card
US7490333B2 (en) 1999-12-10 2009-02-10 Gemalto Sa Capability-based access control for applications in particular co-operating applications in a chip card
FR2802319A1 (en) * 1999-12-10 2001-06-15 Gemplus Card Int CAPACITY ACCESS CONTROL FOR ESPECIALLY COOPERATING APPLICATIONS IN A CHIP CARD
WO2001042887A3 (en) * 1999-12-10 2002-02-07 Gemplus Card Int Access control for co-operating applications in a chip card
US7975057B2 (en) 2000-02-03 2011-07-05 Gemalto Sa Time management at communication protocol layer for a smart card-type device
FR2804819A1 (en) * 2000-02-03 2001-08-10 Gemplus Card Int TIME MANAGEMENT AT COMMUNICATION LEVEL FOR CHIP CARD ENTITIES
WO2001057810A1 (en) * 2000-02-03 2001-08-09 Gemplus Time management at communication level for a smart card-type entity
US7130910B2 (en) 2000-02-10 2006-10-31 Cp8 Technologies Method for high rate data flow transmission on an internet-type network between a server and a smartcard terminal, in particular a multimedia data flow
FR2805062A1 (en) * 2000-02-10 2001-08-17 Bull Cp8 METHOD FOR TRANSMITTING HIGH-RATE DATA FLOW ON AN INTERNET-TYPE NETWORK BETWEEN A SERVER AND A CHIP-CARD TERMINAL, IN PARTICULAR A MULTIMEDIA DATA STREAM
WO2001060040A3 (en) * 2000-02-10 2002-03-14 Bull Cp8 Method for data transmission on an internet-type network between a server and a smart card terminal, comprising intelligent agents
KR100859782B1 (en) * 2000-02-10 2008-09-24 쎄뻬8 테크날러지스 에스에이 Method for high rate data flow transmission on an internet-type network between a server and a smart card terminal, in particular a multimedia data flow
WO2001060040A2 (en) * 2000-02-10 2001-08-16 Bull Cp8 Method for data transmission on an internet-type network between a server and a smart card terminal, comprising intelligent agents
WO2001061486A3 (en) * 2000-02-17 2002-10-17 Interactive Video Technologies Incremental bootstrap class loader
WO2001061486A2 (en) * 2000-02-17 2001-08-23 Interactive Video Technologies, Inc. Incremental bootstrap class loader
WO2001063385A1 (en) * 2000-02-21 2001-08-30 Ncipher Corporation Limited Controlling access to a resource by a program using a digital signature
US7900239B2 (en) 2000-02-21 2011-03-01 Ncipher Corporation Ltd. Controlling access to a resource by a program using a digital signature
JP4509291B2 (en) * 2000-03-30 2010-07-21 大日本印刷株式会社 IC card, IC card program update device, and method thereof
JP2001283160A (en) * 2000-03-30 2001-10-12 Dainippon Printing Co Ltd Ic card and device and method for updating ic card
US7231635B2 (en) 2000-04-28 2007-06-12 Sun Microsystems, Inc. Remote incremental program verification using API definitions
US6651186B1 (en) 2000-04-28 2003-11-18 Sun Microsystems, Inc. Remote incremental program verification using API definitions
US6986132B1 (en) 2000-04-28 2006-01-10 Sun Microsytems, Inc. Remote incremental program binary compatibility verification using API definitions
US6883163B1 (en) 2000-04-28 2005-04-19 Sun Microsystems, Inc. Populating resource-constrained devices with content verified using API definitions
WO2002008897A1 (en) * 2000-07-24 2002-01-31 Cp8_Technologies Protocol for message exchange between applications implanted on an onboard system, and corresponding onboard system
FR2812101A1 (en) * 2000-07-24 2002-01-25 Bull Cp8 Protocol for exchange of messages between applications embedded in a multi-function smart card, uses transmission of calls from master application to cause operating system to load and execute slave application
US6675338B1 (en) 2000-08-09 2004-01-06 Sun Microsystems, Inc. Internally generated vectors for burnin system
US6981245B1 (en) 2000-09-14 2005-12-27 Sun Microsystems, Inc. Populating binary compatible resource-constrained devices with content verified using API definitions
JP2002117381A (en) * 2000-10-05 2002-04-19 Dainippon Printing Co Ltd Ic card
US6901459B2 (en) 2000-10-20 2005-05-31 Trusted Logic Protocol for transmitting a plurality of multiple exchange logic flow of command/response pairs on a single physical exchange channel between master and slave and corresponding system for controlling and monitoring execution of applets
WO2002033866A3 (en) * 2000-10-20 2003-09-04 Trusted Logic Protocol for transmitting a plurality of multiple exchange logic flow of command/response pairs on a single physical exchange channel between master and slave and corresponding system for controlling and monitoring execution of applets
WO2002076126A2 (en) * 2001-03-16 2002-09-26 Schlumberger Systèmes Subscriber identity module for managing a plurality of commands of at least one applet
WO2002076126A3 (en) * 2001-03-16 2002-12-12 Schlumberger Systems & Service Subscriber identity module for managing a plurality of commands of at least one applet
US7085840B2 (en) 2001-10-29 2006-08-01 Sun Microsystems, Inc. Enhanced quality of identification in a data communications network
US7275260B2 (en) 2001-10-29 2007-09-25 Sun Microsystems, Inc. Enhanced privacy protection in identification in a data communications network
US7874492B2 (en) 2001-12-04 2011-01-25 Visa U.S.A. Inc. Method and system for facilitating memory and application management on a secured token
US7010783B2 (en) 2002-03-18 2006-03-07 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using reduced dynamic memory allocation
US7181737B2 (en) 2002-03-18 2007-02-20 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using static procedure return addresses
US6912633B2 (en) 2002-03-18 2005-06-28 Sun Microsystems, Inc. Enhanced memory management for portable devices
US6996802B2 (en) 2002-03-18 2006-02-07 Sun Microsystems, Inc. Method and apparatus for deployment of high integrity software using initialization order and calling order constraints
EP1537516A2 (en) * 2002-08-02 2005-06-08 Cardtronic Method and system for executing applications on a mobile device
EP1537516A4 (en) * 2002-08-02 2006-09-13 Cardtronic Method and system for executing applications on a mobile device
US8548923B2 (en) 2002-10-07 2013-10-01 Sonia Reed Method and system for facilitating data access and management on a secure token
US9430666B2 (en) 2002-10-07 2016-08-30 Visa International Service Association Method and system for facilitating data access and management on a secure token
FR2846770A1 (en) * 2002-11-04 2004-05-07 Oberthur Card Syst Sa Microcircuit card for computer system, has card manager to communicate local code of local object reference obtained from previous reference upon reception of message having logical identifier of computer object
EP1580663A4 (en) * 2002-11-13 2010-04-28 Netac Technology Co Ltd A method for realizing security data storage and algorithm storage by means of semiconductor memory device
EP1580663A1 (en) * 2002-11-13 2005-09-28 Netac Technology Co., Ltd. A method for realizing security data storage and algorithm storage by means of semiconductor memory device
US7484095B2 (en) 2003-01-16 2009-01-27 Sun Microsystems, Inc. System for communicating program data between a first device and a second device
CN100357848C (en) * 2003-01-16 2007-12-26 太阳微系统公司 Signing program data payload in program loading
US7281244B2 (en) 2003-01-16 2007-10-09 Sun Microsystems, Inc. Using a digital fingerprint to commit loaded data in a device
US8121955B2 (en) 2003-01-16 2012-02-21 Oracle America, Inc. Signing program data payload sequence in program loading
US7165246B2 (en) 2003-01-16 2007-01-16 Sun Microsystems, Inc. Optimized representation of data type information in program verification
US7222331B2 (en) 2003-01-16 2007-05-22 Sun Microsystems, Inc. Linking of virtual methods
US7272830B2 (en) 2003-01-16 2007-09-18 Sun Microsystems, Inc. Ordering program data for loading on a device
US8473417B2 (en) 2003-01-16 2013-06-25 Oracle America, Inc. Signing program data payload sequence in program loading
US7571436B2 (en) 2003-04-01 2009-08-04 Panasonic Corporation Device for increasing the execution speed of a linked program
US7702872B2 (en) 2003-12-08 2010-04-20 Giesecke & Devrient Gmbh Java smart card chip having memory area reserved for global variables
WO2005055052A3 (en) * 2003-12-08 2006-05-26 Giesecke & Devrient Gmbh Java smart card chip comprising a memory area reserved for global variables
WO2005055052A2 (en) * 2003-12-08 2005-06-16 Giesecke & Devrient Gmbh Java smart card chip comprising a memory area reserved for global variables
CN102984706B (en) * 2003-12-23 2016-05-04 法国电信公司 Comprise two telecommunication terminals of carrying out space
US7140549B2 (en) 2004-02-24 2006-11-28 Sun Microsystems, Inc. Method and apparatus for selecting a desired application on a smart card
US7165727B2 (en) 2004-02-24 2007-01-23 Sun Microsystems, Inc. Method and apparatus for installing an application onto a smart card
US7374099B2 (en) 2004-02-24 2008-05-20 Sun Microsystems, Inc. Method and apparatus for processing an application identifier from a smart card
US7191288B2 (en) 2004-02-24 2007-03-13 Sun Microsystems, Inc. Method and apparatus for providing an application on a smart card
WO2006024904A1 (en) * 2004-08-30 2006-03-09 Axalto Sa Data access security implementation using the public key mechanism
WO2007091162A1 (en) * 2006-02-10 2007-08-16 Nokia Corporation Improved mobile communication terminal
EP1860589A1 (en) * 2006-05-26 2007-11-28 Incard SA Method for accessing structured data in IC Cards
WO2011085960A1 (en) * 2010-01-13 2011-07-21 Giesecke & Devrient Gmbh Method for providing a secure counter on a terminal
US9020562B2 (en) 2010-03-30 2015-04-28 Qualcomm Incorporated Methods and apparatus for device applet management on smart cards
WO2011123532A1 (en) * 2010-03-30 2011-10-06 Qualcomm Incorporated Methods and apparatus for device applet management on smart cards
US8538480B2 (en) 2010-03-30 2013-09-17 Qualcomm Incorporated Methods and apparatus for device applet management on smart cards
CN102822837A (en) * 2010-03-30 2012-12-12 高通股份有限公司 Methods and apparatus for device applet management on smart cards
EP2535832A1 (en) * 2011-06-17 2012-12-19 Simulity Labs Ltd A method for operating a virtual machine over a file system
US10732977B2 (en) 2017-06-16 2020-08-04 Seoul National University R&Db Foundation Bytecode processing device and operation method thereof
EP3913516A4 (en) * 2019-03-22 2022-04-13 Huawei Technologies Co., Ltd. File access authority authentication method and electronic device

Also Published As

Publication number Publication date
US20080115117A1 (en) 2008-05-15
DE69714752T2 (en) 2003-05-15
US20140245272A1 (en) 2014-08-28
US8881118B2 (en) 2014-11-04
US7117485B2 (en) 2006-10-03
ZA979479B (en) 1998-05-12
BR9713267A (en) 2004-06-15
US9400668B2 (en) 2016-07-26
TW476914B (en) 2002-02-21
US20120254843A1 (en) 2012-10-04
PT932865E (en) 2002-12-31
US7818727B2 (en) 2010-10-19
US8726247B2 (en) 2014-05-13
US20030023954A1 (en) 2003-01-30
AU4911897A (en) 1998-05-22
JP2000514584A (en) 2000-10-31
AU722463B2 (en) 2000-08-03
KR100329063B1 (en) 2002-03-18
DE69714752C5 (en) 2015-08-13
KR20000052759A (en) 2000-08-25
US20110126178A1 (en) 2011-05-26
EP0932865A1 (en) 1999-08-04
HK1021762A1 (en) 2000-06-30
JP3766052B2 (en) 2006-04-12
CN1183449C (en) 2005-01-05
MY126363A (en) 2006-09-29
JP2003141488A (en) 2003-05-16
CN1242086A (en) 2000-01-19
US8881119B2 (en) 2014-11-04
DE69714752D1 (en) 2002-09-19
US6308317B1 (en) 2001-10-23
US20120254844A1 (en) 2012-10-04
ES2184066T3 (en) 2003-04-01
EP0932865B1 (en) 2002-08-14

Similar Documents

Publication Publication Date Title
EP0932865B1 (en) Using a high level programming language with a microcontroller
Chen Java card technology for smart cards: architecture and programmer's guide
AU763958B2 (en) Techniques for permitting access across a context barrier in a small footprint device using global data structures
US6986132B1 (en) Remote incremental program binary compatibility verification using API definitions
KR20010103748A (en) Techniques for permitting access across a context barrier on a small footprint device using an entry point object
AU771765B2 (en) Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges
KR20010108114A (en) Techniques for implementing security on a small footprint device using a context barrier
KR20010103746A (en) Techniques for permitting access across a context barrier in a small footprint device using shared object interfaces
WO2006038103A1 (en) System and method for post-issuance code update employing embedded native code.
US20070168951A1 (en) Java smart card chip having memory area reserved for global variables
Markantonakis et al. Multi-application smart card platforms and operating systems
CA2422634A1 (en) Populating binary compatible resource-constrained devices with content verified using api definitions
MXPA99003796A (en) Using a high level programming language with a microcontroller
Vogt et al. Middleware for smart cards
Markantonakis Java card technology and security
Husemann et al. OpenCard Framework
Interoperability Biometric Application Programming Interface (API) for Java Card™
Interoperability Java Card Biometric API White Paper (Working Document)
Sachdeva Smart Card Operating Systems: Past, Present and Future
AU2004200637A1 (en) Techniques for permitting access across a context barrier on a small footprint device using run time environment privileges

Legal Events

Date Code Title Description
WWE Wipo information: entry into national phase

Ref document number: 97181037.0

Country of ref document: CN

AK Designated states

Kind code of ref document: A1

Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GE GH HU ID IL IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG UZ VN YU ZW AM AZ BY KG KZ MD RU TJ TM

AL Designated countries for regional patents

Kind code of ref document: A1

Designated state(s): GH KE LS MW SD SZ UG ZW AT BE CH DE DK ES FI FR GB GR IE IT LU MC NL

DFPE Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101)
121 Ep: the epo has been informed by wipo that ep was designated in this application
WWE Wipo information: entry into national phase

Ref document number: 1997911833

Country of ref document: EP

ENP Entry into the national phase

Ref document number: 1998 520562

Country of ref document: JP

Kind code of ref document: A

WWE Wipo information: entry into national phase

Ref document number: 1019997003564

Country of ref document: KR

Ref document number: PA/a/1999/003796

Country of ref document: MX

WWP Wipo information: published in national office

Ref document number: 1997911833

Country of ref document: EP

REG Reference to national code

Ref country code: DE

Ref legal event code: 8642

NENP Non-entry into the national phase

Ref country code: CA

WWP Wipo information: published in national office

Ref document number: 1019997003564

Country of ref document: KR

WWG Wipo information: grant in national office

Ref document number: 1019997003564

Country of ref document: KR

WWG Wipo information: grant in national office

Ref document number: 1997911833

Country of ref document: EP