FR2667419A1 - Memory-card application-program debugging process and debugging system - Google Patents

Abstract

The invention relates to chip card application program debugging systems. It applies to cards comprising a microprocessor and an electrically programmable non-volatile memory, this memory containing an application program executable by the microprocessor. To carry out the debugging, a very simple system is used based on the fact that the memory of the application program is electrically programmable. this memory is used to store, on the one hand, provisional and modifiable versions of the application program, and on the other hand a debugging assistance program. The debugging system comprises in practice only a sample smart card (30), a card reader (32), and a microcomputer (34) to control the exchanges between the card and the reader. The method essentially consists in storing in memory the program to be debugged, in modifying an instruction of this program in order to replace it by an instruction for branching into the debugging assistance program, and in launching the application program. The help program provides information on the state of the system at the time of connection.

Description

APPLICATION PROGRAM DEBUGGING METHOD
MEMORY CARD AND DEBUG SYSTEM
The invention relates to the development of smart card application programs incorporating a microprocessor and a program memory.

 If the smart card includes a microprocessor, it is to be able to execute application programs which are in the form of successive instructions given to the microprocessor. These instructions relate to operations internal to the card and to the data exchanges carried out between the card and a card reader in which the card is inserted.

 For the development of any microprocessor application program, it is necessary to go through a debugging phase in which the application program is tested, under conditions as close as possible to reality, and possible errors are detected and then corrected. Microprocessor chip cards are no exception to this rule.

 The smart cards which are more particularly concerned with the present invention are microprocessor cards comprising not only a read only memory (ROM) and a working random access memory (RAM), but also an electrically erasable and reprogrammable memory (EEPROM) or simply electrically programmable (EPROM). The read only memory comprises a fixed, intangible program, representing in particular the operating system of the microprocessor card memory management, access security management, and more generally all the mandatory non-modifiable programs of the smart card. The RAM memory is conventionally used to store data temporarily and volatile during the execution of a program.

The EEPROM or EPROM memory contains non-volatile data and can also contain various application programs, so that the card can have additional functionalities, specific to a given application.

 The invention is particularly interested in debugging application programs stored in non-volatile EEPROM or EPROM memory and executable directly from this memory.

 In the following we will only talk about EEPROM memories, that is to say not only programmable but also electrically erasable, the invention being particularly advantageous in this case.

 To debug an application program which is thus intended to be stored in non-volatile memory to be executed, a development tool is usually used which comprises on the one hand a card simulator and on the other hand an emulator microprocessor.

 Figure I recalls the classic constitution of a microprocessor application development tool.

 The card simulator 10 is an electronic device intended to be connected on the one hand to a card reader 12 (by means of an extension 14 simulating the access contacts of a smart card), and elsewhere on the emulator 16. The simulator replaces the card and has all the resources of the card (RAM, ROM, EEPROM, input / output interfaces, etc.) except the microprocessor.

 The emulator 16 simulates the operation of the card microprocessor and for this purpose includes a microprocessor identical to that of the cards used in the application. The emulator is connected on the one hand to the card simulator 10 so that its microprocessor is in the same environment as if it were actually mounted on a card with the resources thereof; and it is connected on the other hand to a microcomputer 18 capable of controlling it, that is to say of providing it with any desired instruction and capable of exchanging data with it.

 The card reader 12 is also connected to another microcomputer 20 capable of controlling it to allow it to exchange data with the card simulator via the extension 14, exactly as if a real card were inserted in the player. It is by this second microcomputer 20 that we can collect all the useful information on what is happening in the card, the first microcomputer having the role of providing instructions to the microprocessor to make it execute controlled programs.

The development of the application with this classic tool consists of
- have an application program executed by the emulator's microprocessor, either completely or partially, or in step-by-step mode, or by imposing breakpoints, etc.

 - examine the overall and detailed operation, focusing in particular on the contents of the memories and internal registers of the microprocessor at various stages of the program.

- detect functional faults and other errors;
- modify the application program in a direction tending to remove the defects noted;
- and start debugging again with the modified application program, until complete disappearance of the noted faults.

 You therefore need a relatively complicated development tool (an emulator + a simulator + two personal computers) and therefore expensive to perform this debugging.

 On the other hand, the card simulator is rarely perfectly compatible with the card it has to simulate: there may be differences in operating conditions (supply voltage, clock frequency, set of instructions, etc.). ). Indeed, we do not modify the debugging tools, emulator and simulator, each time we make small modifications to the series of cards manufactured.

 Finally, the user of the card, who develops the application, is not the manufacturer of the card and the simulation equipment and he can be on the other side of the planet. Maintaining the development tool can therefore pose difficult problems.

 An object of the invention is to improve the debugging tools for microprocessor smart cards incorporating an electrically programmable non-volatile memory, capable of containing an application program.

 According to the invention, a system for debugging a memory card application program is proposed comprising a sample memory card corresponding to that used in the application to be debugged, this card comprising at least one microprocessor and a non-volatile programmable memory. electrically, a card reader into which this card is inserted, a microcomputer (personal computer or other control console) for controlling the reader and in particular the exchange of data between the card and the reader, the program to be debugged being contained in a first area of the card's non-volatile memory, and a debugging assistance program being contained in a second area of the non-volatile memory.

 In practice, the debugging assistance program comprises means for saving in the non-volatile memory internal data representing the operation of the card at a given instant.

 In particular, it is possible to load into the non-volatile memory an application program comprising a modified instruction at the place where one wishes to observe the internal behavior of the card, this modified instruction being an instruction for connection to the debugging assistance program.

The debugging method according to the invention comprises the operations consisting of
- insert a sample card into a card reader controlled by a microcomputer, the card comprising a microprocessor and an electrically programmable non-volatile memory,
- load into the non-volatile memory, using the microcomputer and the reader, an application program to be debugged, and a program to assist in debugging,
- give via the microcomputer and the reader orders to modify and / or execute the loaded program, execution being possibly modified under the control of the debugging assistance program, and collect the resulting data in the microcomputer program execution,
- modify the application program if necessary according to the results and repeat the steps for loading an application program, execution, and data collection.

 The debugging assistance program may include means for simulating the continuation of a sequence of exchanges between the card and the microprocessor when such a sequence has been interrupted with a view to saving the machine context in the non-volatile memory.

 Therefore, instead of using a card simulator which includes all the resources of the card except the microprocessor, an emulator which includes the microprocessor, and a microcomputer which includes a program for the microprocessor, we simply use a sample card, identical to the one that will actually be used in the application. This card includes its own resources (RAM, ROM and non-volatile), its microprocessor, an application program stored in non-volatile memory and a debugging assistance program stored in the same memory and able to partially modify the execution. of the application program. Only a card reader and a single microcomputer to control it are necessary to carry out debugging. Debugging is carried out by successive loads of modified programs until # complete elimination of errors. It is thus very advantageous to use the fact that the application program is directly executable from a non-volatile memory and the fact that this memory is electrically programmable from the card reader.

 The microcomputer is capable in particular of inserting breakpoints (instructions for connection to the debugging assistance program) at designated points of the application program. The debugging aid program stored in non-volatile memory is preferably capable of reading and modifying the contents of the various memory areas (living and non-volatile) and of saving in non-volatile memory the contents of various registers of the card, this at any time during the exchange process between the card and the reader.

Other characteristics and advantages of the invention will appear on reading the detailed description which follows and which is given with reference to the drawings in which
- Figure 1, already described, shows the conventional constitution of a microprocessor smart card application development tool;
- Figure 2 shows the constitution of the development tool according to the invention;
- Figure 3 shows schematically the content of the chip of a smart card;
- Figure 4 shows the organization of the non-volatile memory with data areas and executable code areas;
- Figure 5 shows an example of an exchange sequence between a smart card and a card reader.

 FIG. 2 represents the development tool according to the invention allowing the debugging of an application program for a microprocessor card when this program is stored in an internal non-volatile memory, electrically programmable (in general EEPROM therefore also erasable electrically), from the integrated circuit chip on the card.

The tool is very simple: it includes
a sample card 30 corresponding exactly to the cards which will be used when the program is finally ready;
a card reader 32 into which the card can be inserted and data exchanged with it according to a procedure which is not different from the procedure which will be used in the final application;
- And a microcomputer 34 to control the reader and therefore the exchanges with the card. The exchanges with the card are conventionally serial exchanges.

The exchanges between the microcomputer and the reader can be done by a classic RS232 link.

 The sample card, like the card of the final application conventionally comprises, as represented in FIG. 3, a microprocessor (CPU) with all its registers and internal operators, a ROM program memory, for the frozen programs already set point and mainly for the operating system of the card, a random working memory (RAM), and an electrically programmable non-volatile memory, preferably EEPROM, which can contain data but also executable code, in particular the program application that we are trying to develop. The card can of course include other circuits and in particular security circuits establishing the authorizations for exchanges between the reader and the card. These exchanges are made by I / O input / output connections, in principle in serial mode.

 During the development of the application program contained in non-volatile memory, a first zone Z1 of this memory is used to contain the program to be debugged, and another memory zone Z2 to contain a program for assisting in debugging. These two zones contain code executable by the microprocessor of the card. A third zone Z3 serves as a memory for non-volatile data; these three zones are accessible in read, write and erase by the microprocessor. Other zones can also be provided, for example to contain information that is not accessible for reading and / or programming and / or erasing by the microprocessor.

 FIG. 4 represents this organization of the non-volatile memory of the sample card which is used for debugging.

 The debugging assistance program which is contained in the zone Z2 of the memory is a program allowing the microprocessor to execute various operations making it possible to analyze the progress of the main program; for example, this help program includes instructions for storing the contents of registers and random access memory of the microprocessor in non-volatile memory, then reading them in order to send them to the microcomputer. It also makes it possible to read and modify areas of the random access memory or non-volatile memory.

 The development of the program takes place in the following manner: by the microcomputer 34 and by means of the card reader 32 controlled by the microcomputer, the program of load in the zone Z1 of the non-volatile memory of the card application; we modify for example an instruction of this program to introduce a breakpoint (allowing to examine the state of the card at the moment when this point is reached); the breakpoint consists of a connection instruction to the debugging assistance program that has been stored in zone Z2.

 The application program is executed until the connection instruction, from which the debugging assistance program takes over to perform certain operations, and in particular the reading of certain registers and memories of the circuit. These readings are stored in EEPROM memory, in the data area Z3. These statements will be read later by the microcomputer 34; they make it possible to control the operation of the card and to detect operating errors.

 The debugging assistance program also makes it possible to modify the content of certain areas of random access memory or non-volatile memory, and even the content of certain internal registers of the microprocessor.

 In practice, the standards for using smart cards provide for a fairly strict exchange protocol between the card and the reader.

 This protocol defined by the ISO 7816-3 standard is also called T = O; it is represented diagrammatically in FIG. 5: it is the card reader which has permanent control of the exchanges and not the card (during the development of the application, the reader is controlled by the microcomputer 34); the reader sends CMD command bytes to define the operations to be performed by the card; the card responds with a PB procedure byte; then the data exchanges take place (DATA IN or DATA OUT signals depending on whether the card receives or transmits data); and finally the card transmits two bytes of end of procedure ME1, ME2. If the sequence does not follow this procedure, the reader sends an error message and regains control. This standard procedure is given as an example.

 One of the important functions of debugging is the knowledge of the machine context (content of the random access memory, content of the microprocessor registers) at a given instant in the progress of the application program; this means that a sequence of exchanges between the reader and the card will necessarily be interrupted if we need to know the context in the middle of this sequence. However, the reader reacts to any break in sequence by issuing an error message and by resetting all the registers.

 According to the invention, a means is proposed to allow nevertheless the knowledge of the machine context at a desired instant of a sequence of exchanges.

 To achieve this goal, the debugging assistance program (to which the application program is diverted to the desired location) contains instructions for saving the contents of registers and memories that we want to observe, and instructions for simulating data exchange with the reader. The backup is made in the data area Z3 of the EEPROM memory.

 Consequently, the analysis sequence proceeds as follows: the application program is loaded into the EEPROM memory (zone Z1) with a modified instruction at the place where one wishes to observe the machine context; the modified instruction is a connection instruction to the debugging assistance program (zone Z2); the debugging assistance program then writes to EEPROM memory (zone Z3) the contents of the registers and memories and it performs a fictitious sequence of exchanges with the card reader (from the point where this sequence was interrupted) to leave believe the reader that the current sequence is proceeding normally.

 For example, if the current sequence is a sequence of sending data by the card and if we want to observe the machine context just after the PB procedure byte, the debugging assistance program will send any data to the reader during saving the machine context. If the current sequence was a sequence of data reception by the card, the debugging assistance program would simulate reception of data.

 The machine context saved in non-volatile memory at specified addresses in the zone Z3 can be read later: the microcomputer 34 can read or write to any address in the non-volatile memory except possibly in areas with reserved access. The revelation of the content of the microprocessor registers by the subsequent reading of the zone Z3 makes it possible to understand the errors of the program of the application and to correct them.

For example, for the ST8 microprocessor of
SGS-THOMSON MICROELECTRONICS SA, the series of debugging microprocessor instructions used to save the contents of registers, is, in assembly language, the following
Input

SS tttttttttttttttttttttttt * ttt 56 * TSA: TRANSFER SP 10 A * 57 58 ISA MACRO
S9 FCB t9E 60 EUDH 61 62 63 E600 ORG SE600
G4 E600 BACKUP BLKB 4D, OL RAM AND # 65 SAVE AREA * REGISTERS A, X, CC AND SP 66 67 E628 24 04 CSET BHG 68 E62A 10 SA BSET 69 E62C 20 02 BRA ZSET t RECOVERY FROM CC, A ET X 70 E62E 11 BA CCLR BCLR 71 * 72 E630 26 04 BHE ZCLR tn E632 12 BA BSET 1, REG CC * 74 E634 20 02 BRA NSET * 75 E636 13 SA ZCLR BCLR 1, REG CC t 76 t 77 E638 2A 04 HSET BPL WCLR 78 E63A 14 SA BSET 2, REG CC 79 E63C 20 02 BRA ISET 80 E63E 15 OA NCLR BCLR 2, REGCc * 82 2C 04 ISET BHC ICtR t 83 F642 16 SA * 84 E644 20 02 SRA HSET t as 17 86 87 E648 28 04 BUCC HCLR t 88 E64A 18 * 89 E64C 20 02 BRA NIT REG t 9D E64E 19 SA HCLR BCLR 4, REG CC * 91 t 92 E650 87 88 WKTREG STA REG A t 93 E652 BE 89 STX REG K * 94 5654 TSA * 95 E654 9E FCB tE 96 E655 ERDM 97 5655 B7 88 STA RCC *
This series of instructions can be used as is on all microprocessors of the 6805 type. It must be modified according to the language used by the microprocessor, for the other microprocessors. Its structure and purpose are deduced from those indicated above.

Claims (6)

 1. A memory card application program debugging system comprising a sample memory card (30) corresponding to that used in the application to be debugged, this card comprising at least one microprocessor and one electrically programmable non-volatile memory, one card reader (32) into which this card is inserted, a microcomputer (34) for controlling the reader and in particular the exchange of data between the card and the reader, the program to be debugged being contained in a first zone (Z1) of the non-volatile memory of the card, and a debugging assistance program being contained in a second zone (Z2) of the non-volatile memory.  2. System according to claim 1, characterized in that the debugging assistance program comprises means for saving in the non-volatile memory internal data representing the operation of the card.  3. System according to one of claims 1 and 2, characterized in that it comprises means for loading into the non-volatile memory an application program comprising a modified instruction at the place where one wishes to observe the internal behavior of the card, this modified instruction being a connection instruction to the debugging assistance program.  4. Method for debugging a smart card application, this method being characterized in that it comprises the operations consisting in:  - insert a sample card (30) into a card reader (32) controlled by a microcomputer (34), the card comprising a microprocessor and an electrically programmable non-volatile memory,  - load into the non-volatile memory, using the microcomputer and the reader, an application program to be debugged, and a program to assist in debugging,  - give via the microcomputer and the reader orders to modify and / or execute the loaded program, execution being possibly modified under the control of the debugging assistance program, and collect the resulting data in the microcomputer program execution,  - modify the application program if necessary according to the results and repeat the steps for loading an application program, execution, and data collection.  5. Method according to claim 4, characterized in that the debugging assistance program comprises means for saving in the non-volatile memory the contents of memories and internal registers representing the machine context of the microprocessor.  6. Method according to claim 5, characterized in that the debugging assistance program comprises means for simulating the continuation of a sequence of exchanges between the card and the microprocessor when such a sequence has been interrupted in order to saving the machine context in non-volatile memory.