WO2006045924A1 - Protection contre les attaques par generation de fautes sur les instructions de saut - Google Patents

Protection contre les attaques par generation de fautes sur les instructions de saut Download PDF

Info

Publication number
WO2006045924A1
WO2006045924A1 PCT/FR2005/002582 FR2005002582W WO2006045924A1 WO 2006045924 A1 WO2006045924 A1 WO 2006045924A1 FR 2005002582 W FR2005002582 W FR 2005002582W WO 2006045924 A1 WO2006045924 A1 WO 2006045924A1
Authority
WO
WIPO (PCT)
Prior art keywords
instruction
batch
jump
program
instructions
Prior art date
Application number
PCT/FR2005/002582
Other languages
English (en)
Inventor
Christophe Giraud
Hugues Thiebeauld De La Crouee
Original Assignee
Oberthur Card Systems Sa
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
Application filed by Oberthur Card Systems Sa filed Critical Oberthur Card Systems Sa
Priority to US11/665,991 priority Critical patent/US8266423B2/en
Publication of WO2006045924A1 publication Critical patent/WO2006045924A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
    • G06F21/52—Monitoring 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
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
    • G06F21/55—Detecting local intrusion or implementing counter-measures

Definitions

  • the present invention relates to a method for securing a computer program and to a device, in particular a microcircuit card (also called a "smart card”) implementing such a method.
  • a device for generating the security of a program associated with this method.
  • any program whatever the computer language and storage means used.
  • the computer program can be written in machine language, assembler, C, C ++, Java, VHDL.
  • the program can be stored in a permanent memory, for example in a ROM or EEPROM memory or on a hard disk, or in a volatile memory, for example of the RAM type.
  • the program can be also materialized by an integrated circuit, for example FPGA type or even an ASIC (Application Specifies Integrated Circuit) circuit.
  • the present invention aims in particular at detecting an attack intended to modify the progress of the execution of a computer program running on a secure electronic entity, for example a microcircuit card, a secure PCMCIA card (for example a card). IBM4758 card), a USB key or a passport integrating a contactless chip into one of its pages, and the triggering of a countermeasure to this attack.
  • a secure electronic entity for example a microcircuit card, a secure PCMCIA card (for example a card).
  • IBM4758 card for example a card
  • USB key for example a passport
  • passport integrating a contactless chip into one of its pages
  • the present invention is particularly intended to detect attacks by disruption of the operation of an electronic entity, for example attacks of the type "attacks by fault generation” (in English "Fault Attack”).
  • Such attacks are particularly active on certain instructions in a program, including conditional and unconditional branching instructions.
  • branching instructions are for example the "if", "case” instructions in language C.
  • the compilation of such connection instructions in assembly language produces a conditional or unconditional jump instruction to an address or instruction of the program to be reached.
  • the instruction to be reached is identified by a label in an assembly program.
  • conditional or unconditional jump instructions of the C language are translated into "jnz" type instructions (which can be translated as “jump if the result of the previous instruction is not equal to 0"), " jz "(which can be translated as” jump if the result of the previous instruction is equal to 0 "),” jmp "(which can be translated as” jump ").
  • the instruction to be reached is identified by its address passed as argument (or parameter) of the jump instruction.
  • This address is either an increment or a decrement in number of bytes with respect to the address of the jump instruction, also called relative address, or an absolute address, that is to say, a fixed address within of memory.
  • Jump instructions usually include a relative jump address.
  • the relative address represents the difference in bytes between the address of the instruction to be reached and the address of the jump instruction.
  • the execution of a jump instruction can in the vast majority of cases be disturbed, for example, by a fault attack, leading to a jump to an address not provided by the program. initial.
  • the result obtained is equivalent to a modification of the value of the address passed in argument of the jump instruction. This value is changed randomly.
  • the address of the jump is a relative address
  • the address that would be reached by the jump instruction thus disturbed would be an address included in the set of addresses accessible from the jump address.
  • a fault attack of this address causes a jump in a memory zone between - (2 7 - 1) and 2 7 - 1 bytes or between -127 and +127 bytes with respect to the address of the jump instruction.
  • the address reached by the jump following the attack by fault generation is equiprobable over this interval.
  • the relative address can also be coded on 2 or 3 bytes or more, in a memory zone all the more important.
  • the instruction area preceding and following the jump instruction defined by the relative address therefore typically consists of a hundred or so instructions. maximum.
  • the modification of the resulting jump address may result in unauthorized access to a critical instruction of the program or sensitive data, for example keys and thus allow an attacker to jeopardize the security of the system.
  • the skilled person has various means to secure a computer program and in particular to fight against fault attacks in a microcircuit card.
  • One method is to install, in the components of the microcircuit cards, sensors that detect such attacks.
  • the present invention aims at a security method of the software type and does not have the above disadvantages.
  • it proposes a method of securing a computer program against fault attacks.
  • This method is applicable in particular in a smart card.
  • at least one jump instruction is identified in the program with a relative address chosen from among a plurality of possible relative addresses, and making it possible to reach a target address within a memory zone extending before and after of this jump instruction and grouping this plurality of possible relative addresses.
  • an instruction is identified to preserve.
  • At least one first nonoperating batch including at least one instruction is inserted, this insertion being done in such a way that:
  • this insertion is compatible with maintaining the address targeted by the jump instruction inside the memory zone
  • the security method according to the invention therefore consists in inserting one or more instructions within the memory zone extending upstream and downstream of the jump instruction, and comprising all the addresses accessible from the relative address. referred to by the jump instruction, ie a memory area from -127 bytes to +127 bytes when this relative address is coded on a byte.
  • the security of the instruction to be preserved is increased. Indeed, during a fault attack generating a modification of the relative address reached by the jump instruction, the instruction to be preserved is less likely to be reached, and therefore, this instruction is less likely to to be executed at a time when this is not planned, while inserted instructions are privileged.
  • the inserted instructions form a batch, and this batch is non-operative, that is, it does not modify the functional behavior of the program during normal execution of the program.
  • the instructions that make up a batch include the empty statement (for example, in assembler the "nop" statement meaning "non-operative"), or an instruction having no effect on the result of the program execution alone. or combined with other instructions in normal operation.
  • Inserting the nonoperating batch may imply a modification of the jump instruction argument to reach the targeted address.
  • the nonoperating batch insertion must be compatible with the maintenance of this address targeted by the jump instruction inside the previously defined memory zone.
  • the program may include instructions that are instead to promote the safety of the program.
  • the instructions to be performed in case of a valid test are generally to be preserved while the instructions in case of invalid test are often favored.
  • the method comprises the following steps: identification in the program of a security batch comprising at least one instruction to be executed, insertion of a nonoperating batch, distinct or not from the first batch operating, preceding the safe lot identified and likely to favor its execution.
  • This embodiment therefore involves, on the one hand, identifying a security batch, that is to say a set of instructions carrying out a sensitive action, the non-execution of which can jeopardize the security of the system, then, on the other hand, to favor the execution of the identified security batch, since this lot must be executed for the security of the program and the card, by previously adding to this lot a nonoperating lot which improves the probability of performing this lot safe.
  • a jump instruction can reach that nonoperating batch that will force the execution of the safe batch instructions, thus ensuring that this batch is executed.
  • the nature of the first nonoperating batch may depend on the relative positions of the jump instruction, the address targeted by the jump, and the instruction to be preserved.
  • the first non-operating batch is inserted in the program so that a bypass instruction normally prevents the execution of the instructions of the batch and an ejection instruction to an action program at the end of the nonoperating batch, prevents the execution of instructions downstream of this non-operating batch.
  • This embodiment is particularly advantageous because in normal operation of the program or when the jump instruction normally reaches an instruction upstream of the inserted nonoperating batch, a bypass instruction prevents the execution of instructions from this non-operative batch.
  • an ejection instruction located substantially at the end of the inserted nonoperating batch is present such that, in the case of a disturbance of the jump instruction, the jump reaches that first non-operating instruction batch.
  • this ejection instruction prevents the execution of instructions downstream of the non-operating batch and thus prevents the execution of the instruction to preserve if it is downstream of this batch.
  • the security of the system is greatly increased since this non-operating batch, executed in case of fault, avoids reaching the instruction to preserve and execute this instruction to preserve at a time when it is not planned.
  • the security is improved by the simple fact that there is ejection if the jump succeeds, following a disruption, in this lot not operating.
  • the action program comprises a security batch comprising at least one instruction to be executed.
  • the action program includes instructions whose execution must be performed for the program security.
  • the security of the program is substantially improved by increasing, in the event of a disturbance, the probability of executing a security batch comprising a series of instructions important for the security of the program.
  • the bypass instruction is part of the program to be secured and precedes the nonoperating batch so that this nonoperating batch is not normally executed.
  • the bypass instruction is at the beginning of the nonoperating batch and returns to the first instruction of the program downstream of this nonoperating batch.
  • the nonoperating batch may be inserted downstream of any program instruction, the first instruction of that batch (bypass instruction) returning to that instruction.
  • Some positioning rules of the first non-operating batch can be advantageous and allow a simplification of the structure of this batch.
  • the insertion of the first non-operating batch is performed after the first of said jump instructions or to preserve.
  • This feature advantageously contributes to securing a program as it appears below.
  • the nonoperating batch is inserted between the instruction to be preserved and the jump instruction if the instruction to be preserved precedes the jump instruction.
  • This feature is particularly advantageous, because its function is to move the instruction to be preserved from the batch insertion jump instruction between the two instructions, and to go back up this instruction to preserve within the memory area accessible to from the address of the jump instruction and preceding the jump instruction.
  • the instruction to preserve being raised in the memory zone preceding the jump instruction, in case of disturbance of the relative address of the jump, the chances of executing this instruction are diminished despite the fact that the addresses are equiprobably accessible. Indeed, during a jump, the execution continues by incrementing the address of the instructions, the probability of executing the instruction to preserve after insertion of nonoperating batch is diminished.
  • the nonoperating batch comprises a number of instructions such that, after insertion, the instruction to be preserved is upstream of the memory area accessible by the jump instruction.
  • the insertion of the nonoperating batch is performed such that it causes the output of the instruction to preserve the memory area preceding the jump instruction, making access impossible from the jump instruction .
  • the nonoperating batch is inserted so as to be executed only in case of disturbance of the jump instruction, an instruction Contouement normally preventing the execution of instructions of this non-operating batch.
  • this nonoperating batch of instructions inserted is not executed, and therefore the perturbation in terms of program performance, performance perturbation induced by the addition of a batch of programs. instructions, is very limited.
  • this batch also comprises at the end of the non-operating batch, an ejection instruction preventing the execution of instructions downstream of this non-operating batch.
  • This instruction is present so that, in the case of a disruption of the jump instruction, the hop reaches a nonoperating instruction batch, an eject instruction prevents the execution of instructions downstream of the batch. nonoperating and thus prevents the execution of the instruction downstream of the nonoperating batch.
  • the nonoperating batch insertion is performed between the jump instruction and the instruction to be preserved so that it is executed only in the event of a disturbance of the instruction of jump, and an eject instruction at the end of the nonoperating batch prevents the execution of instructions downstream of that nonoperating batch.
  • this batch must contain at least one ejection instruction.
  • the latter allows in case of disturbance of the jump instruction, the jump to this lot, to prevent the execution of instructions downstream of this batch and therefore the instruction to preserve.
  • the nonoperating batch is inserted just upstream the address targeted by the jump instruction when the address targeted by the jump instruction is upstream of the instruction to be preserved.
  • a tamper instruction normally prevents the execution of non-operating batch instructions.
  • the contouement instruction is at the beginning of the nonoperating batch, and returns to the first instruction of the program downstream of this nonoperating batch.
  • the nonoperating batch can be inserted downstream of a program instruction, whatever the program instruction.
  • the first instruction of this batch is a contouement instruction of this batch returning to the first instruction downstream of this batch.
  • the various embodiments prevent the execution of nonoperating batches and therefore limit the potential performance losses due to the insertion of code.
  • the nonoperating batch is inserted between the address targeted by the jump instruction. and the instruction to preserve.
  • the instruction to be preserved is at the end of the memory zone after the jump instruction.
  • the nonoperating batch comprises a number of instructions such that after insertion, the instruction to be preserved is downstream of the memory zone.
  • the batch insertion causes the output of the instruction to preserve the memory area preceding the jump instruction, making access impossible from the jump instruction.
  • the insertion is performed after the second of said program instructions so that a tamper instruction normally prevents the execution of batch instructions and an eject instruction at the end. batch prevents the execution of instructions downstream of this batch.
  • the bypass instruction is part of the program to be secured and precedes the nonoperating batch so that this nonoperating batch is not normally executed.
  • bypass instruction is at the beginning of the nonoperating batch returning to the first program instruction downstream of this nonoperating batch.
  • the nonoperating batch can be inserted downstream of a program instruction, whatever the program instruction.
  • the nonoperating batch inserted and therefore arrive at an ejection instruction the first instruction of this batch is a bypass instruction of this batch returning to the first instruction downstream of this batch.
  • the various embodiments prevent the execution of nonoperating batches and thus limit the potential performance losses due to the insertion of code.
  • the instruction to preserve preceding the safe lot, the instruction to be preserved and the security lot being on the same side with respect to the jump instruction, the insertion of the nonoperating lot is carried out between the instruction to preserve and safe lot.
  • the insertion of the nonoperating lot is carried out so as to lead the execution of the program towards the security lot in case of attack.
  • the execution of the security lot is favored, however, by preserving the instruction to be preserved.
  • the insertion of the nonoperating batch is such that the safe lot is at the end of the memory zone.
  • the memory area following the jump instruction includes the instruction to be preserved just after the jump instruction, then the memory area is filled with a set of nonoperating instructions forming a nonoperating batch, such as so that the safe lot is at the end of the memory area.
  • the insertion of the nonoperating batch is such that the instruction to be preserved is at the beginning of the memory zone.
  • the security lot precedes the instruction to be preserved, the security lot and the instruction to be preserved are on the same side with respect to the jump instruction, the insertion of the non-operating lot is upstream of the safe lot. and is performed on the same side as the safe lot with respect to the jump instruction.
  • the insertion of the nonoperating lot is carried out so as to lead the execution of the program towards the security lot in case of attack.
  • the execution of the security lot is favored, however, by preserving the instruction to be preserved.
  • the insertion of the nonoperating batch is such that the instruction to be preserved is at the end of the memory zone.
  • At least one other instruction to be preserved is identified within this memory zone and, to secure this other instruction, another non-operating batch is inserted. comprising at least one instruction, this instruction being executed respecting the said conditions.
  • this memory zone before insertion of a non-operating batch, at least one other instruction to be preserved is identified within this memory zone, and the non-operative batch is inserted so as to respect the conditions to each of the instructions to be preserved.
  • this memory zone comprises at least 90% of instructions belonging to nonoperating batches inserted.
  • a nonoperating batch comprises a plurality of instructions.
  • the nonoperating batch comprises at least one ejection instruction to an action program.
  • This embodiment makes it possible not only to limit the effects of a disturbance but also to detect these disturbances and to launch action programs in order to counter attacks or to make the progress of a program reliable.
  • the inserted nonoperating batch comprises at least one eject instruction to a subprogram of action.
  • the action program includes a security batch comprising at least one instruction to be executed.
  • the action program includes instructions whose execution must be performed for the security of the program.
  • the security of the program is substantially improved by increasing, in the event of a disturbance, the probability of executing a series of important instructions for securing the program.
  • the action program includes instructions for premature termination of program execution.
  • the program has detected an attack or a disturbance during execution, which results in the end of the execution of the program.
  • the action program includes instructions for resetting the execution of the program.
  • the invention also relates to a method for the secure execution of a program against fault attacks, in particular in a smart card.
  • the method implements a step of securing the program according to the invention prior to the execution of said program.
  • the invention relates to a device for securing a program comprising means for identifying in this program at least one jump instruction comprising a relative address chosen from a plurality of possible relative addresses, and making it possible to reach an address within a memory area extending before and after this jump instruction and gathering all the addresses accessible from the relative address, a means for identifying an instruction to be preserved within the memory zone and means for inserting at least one nonoperating batch including at least one instruction for securing at least that instruction.
  • the invention also relates to an information medium readable by a computer system, possibly totally or partially removable, in particular a CD-ROM or magnetic medium, such as a hard disk or a diskette, or a transmissible medium such as an electrical or optical signal, this medium information comprising instructions of a computer program for implementing a security method as briefly described above, when the program is loaded and executed by a computer system.
  • a computer system possibly totally or partially removable, in particular a CD-ROM or magnetic medium, such as a hard disk or a diskette, or a transmissible medium such as an electrical or optical signal
  • the invention also relates to a computer program stored on an information medium, this program comprising instructions for implementing a security method as briefly described above, when this program is loaded and executed. by a computer system.
  • FIG. 1 is a block diagram of the security method according to the invention, in a case where the instruction to be preserved precedes the jump instruction.
  • FIG. 2 is a particular case of FIG. 1 where the instruction to be preserved further precedes the address targeted by the jump instruction.
  • FIG. 3 is another particular case of FIG. 1 where, on the other hand, the address targeted by the jump instruction precedes the instruction to be preserved.
  • FIG. 4 is a block diagram of the security method according to the invention, in a case where the jump instruction precedes the instruction to be preserved.
  • FIG. 5 is another particular case of FIG. 4 where the instruction to be preserved precedes the address targeted by the jump instruction.
  • FIG. 6 is another particular case of FIG. 4 where the address targeted by the jump instruction precedes the instruction to be preserved.
  • FIG. 7 is a third block diagram of the security method according to the invention, in a case where the jump instruction precedes the instruction to be preserved.
  • FIG. 8 is a second block diagram of the security method according to the invention, in a case where the jump instruction precedes the instruction to be preserved.
  • FIG. 9 is an example of a computer program that can be secured by a security method according to the present invention.
  • FIG. 10 is the assembly code obtained after execution of the securing method according to the invention in the example of FIG. 9.
  • FIG. 11 is a second example of a computer program that can be secured by a security method according to the present invention.
  • FIG. 12 is the assembly code after execution of the security method according to the invention in the example of FIG. 11 of FIG. so that the instruction to preserve is upstream of the memory area accessible by the jump instruction.
  • FIG. 13 is a third example of a computer program that can be secured by a security method according to the present invention.
  • FIG. 14 is the assembler code after execution of the security method according to the invention in the example of FIG. 13 so that the instructions inserted comprise a bypass instruction and an ejection instruction.
  • FIG. 15 is the assembler code after execution of the security method according to the invention applied with a conditional jump instruction.
  • FIG. 16 is an assembly code alternative after execution of the security method according to the invention applied with a conditional jump instruction.
  • a program can usually be used to identify instructions to be preserved, to perform wisely, and instructions to favor, the execution of which contributes to the reliability of the program.
  • the instructions to be executed after verification of various tests can often be considered as sensitive instructions that it is better to preserve, while correction instructions, to be executed when the tests are negative, can often be as safe instructions that should be promoted.
  • an alternative between an instruction to be preserved and an instruction to be favored can generally be identified and that the reduction of the chances that the instruction to be preserved will be executed in the event of disturbance or disruption of jumping often amounts to increasing the probability of executing other instructions.
  • a non-operating lot can be inserted into the starting program which is compatible with the maintenance of the address referred to in the jump instruction inside the accessible memory zone which does not disturb the normal course of the program.
  • a general solution is, at any point, to insert a batch beginning with a bypass instruction that sends to the instruction following this jump and ending with an eject instruction to a program or subroutine (reset , repetition of the test, additional tests, etc., or destruction of the card).
  • Such a batch thus acts as a trap detecting erroneous jump results, in particular results of a jump disturbed by an attack.
  • various special cases can be identified that specifically improve the preservation of the instruction to be preserved (possibly by promoting security instructions) and / or simplify the constitution of the non-operating batches.
  • the particular cases can be defined with reference to the relative positions of the instruction to be preserved and the jump instruction, or even the address targeted by the jump.
  • FIG. 1 there is shown a block diagram according to the invention, wherein a jump instruction is followed by a relative address allowing at its execution to reach a memory address shown.
  • the address passed in argument of the jump instruction is a relative address coded on n binary elements. For example, the number of bits is 8 representing one byte.
  • This instruction makes it possible to execute a jump in a memory ranging from - (2 n "1 -1) to 2 ⁇ " 1 -1. According to the example considered, the memory area accessible by the jump instruction ranges from -127 to +127 bytes.
  • At least one instruction to be preserved is identified.
  • An instruction to preserve is identified as an instruction dangerous for the security of the system if it is executed at a time when this is not planned.
  • an instruction to secure can be defined as either an instruction to be executed only at the appropriate time, or an instruction to be executed at any given time during the execution of the program.
  • an instruction to be preserved is identified in the zone that can be accessed by a jump instruction and upstream of this jump instruction.
  • this instruction can equally well reach all the instructions belonging to the memory zone ranging from - (2 n "1 -1) to 2 n" 1 -1.
  • non-operative instructions are inserted between the instruction to be preserved and the jump instruction. This insertion has the role of leaving the instruction to preserve the memory area accessible by the jump instruction, knowing that the execution of the program is by increasing address.
  • the instruction to preserve should not be positioned at a higher address than its initial address when inserting an operating batch. Indeed, during an attack on the jump address, if the jump results in a lower address or an address equivalent to the instruction to be preserved, and if the instruction to preserve is positioned at a higher address then this instruction to preserve will be executed.
  • nonoperating instructions forming a nonoperating batch are, for example, instructions whose facts are neutralized, that is, for example, instructions for incrementing and decrementing a variable, or assignment instructions. a variable not used in the rest of the program.
  • the non-operating batch being a sequence of instructions having no effect on the program, is inserted in the program so that the bypass instruction normally prevents the execution of the instructions in that batch and an instruction of Eject located at the end of this batch prevents the execution of instructions downstream of this batch.
  • the nonoperating batch is inserted between the instruction to be preserved and the jump instruction.
  • This batch may comprise firstly, substantially in the first instructions, a contouement instruction to reach the instruction following the non-operating batch. If a tamper instruction is located before this non-operating batch, then the batch optionally includes this tamper instruction.
  • this batch may comprise substantially at the end, an eject instruction to an action program, this instruction preventing the execution of instructions downstream of this batch.
  • the eject instruction is a nonoperating instruction of type jump instruction, or subroutine call instruction which has as its argument the address of the action program.
  • This action program is composed of at least one instruction to execute a countermeasure or more generally, a safe lot.
  • a countermeasure for example, it could be a program to destroy the card, run an infinite loop, or reset the program. It can also be a safe lot, that is to say a set of instructions carrying out a sensitive action whose non execution can jeopardize the security of the system.
  • the security batch may be designed to read a sensitive key or perform authentication before allowing access.
  • the instruction to be preserved precedes the address targeted by the jump instruction.
  • a non-operating batch must be inserted between the instruction to be preserved and the address targeted by the jump.
  • the instruction to be preserved is far from the jump instruction and is preferably outputted from the area accessible by the jump instruction.
  • this non-operating batch comprises a number of instructions such that, after its insertion, the instruction to be preserved is output from the memory area accessible by the jump instruction.
  • the instruction to preserve is preferably remote from the jump instruction.
  • the nonoperating batch is inserted between the jump instruction and the instruction to be preserved.
  • this batch comprises substantially at the end of this batch of instructions, an ejection instruction preventing the execution of instructions downstream of this batch.
  • the nonoperating batch is inserted between the jump instruction and the instruction to be preserved thus repelling the instruction to be preserved.
  • the jump instruction as shown in Figure 5.
  • the nonoperating batch is preferably inserted downstream of the address targeted by the jump instruction.
  • This insertion has the role of leaving the instruction to preserve the memory area accessible by the jump instruction.
  • the insertion of a non-operative batch can be carried out just before the address targeted by the jump instruction when the address targeted by the jump instruction is upstream of the instruction to be used. preserve.
  • the insertion of a nonoperating batch can be carried out after the instruction to be preserved when it is downstream of the jump instruction.
  • This batch preferably comprises a bypass instruction, substantially in the first instructions of this batch, and an ejection instruction at the end of the batch which prevents the execution of instructions downstream of this batch.
  • non-operative batches can be used to promote a safe lot, for example the instructions constituting, after a jump, the alternative to the instructions to be preserved.
  • the method can by the insertion of nonoperating lot, promote the execution of a lot of security instructions, the latter being formed of a set of instructions that must be executed for program security.
  • Safe batch instructions are instructions that perform sensitive actions, and failing to execute them after an attack, while the instruction was normally executed, can jeopardize the security of the system.
  • a security batch may consist in accessing a memory key, for example of the EEPROM type, before executing an encryption of sensitive data, the result of the encryption to be sent by the card to the terminal. If the encryption key is not read after an attack, the card may return the sensitive data to the terminal, in clear or encrypted with a degenerate key, which may jeopardize the security of this data. This is especially important when handling secret data.
  • a memory key for example of the EEPROM type
  • the calculation and verification of a checksum value for example, accompanying each record stored in the memory of a smart card, must be executed after reading data in a file, in particular following a read command (read instruction), and before the card transmits the read data to the terminal in which the smart card is inserted.
  • the card verifies that it has read the data and that the data it stores are correct.
  • An attack may consist, for example, in disrupting the reading so as to perform this reading in unauthorized areas, an area that may include a secret.
  • the check of the checksum value performed by the card poses a problem for an attacker, since the disturbed reading in most cases causes the card to read the checksum value in a check box.
  • the memory where there is other data and not this checksum value.
  • this checksum value resulting from data read from the memory by the card and the checksum value calculated by the card do not match. This card then detects a reading error and does not return the data read to the terminal.
  • the security batch can thus be an anomaly treatment, resulting for example from a functional error or the detection of an attack.
  • a nonoperating batch is inserted such that during a fault, it increases the probability that the jump reaches the nonoperating lot, this nonoperating lot leading to the execution of the safe lot.
  • FIG. 9 illustrates an assembler program in which two instructions to be preserved upstream of the jump instruction are represented. These instructions are to be preserved because they can be dangerous if they are executed at a time unforeseen by the program, following for example a fault attack. These two instructions are on the one hand the instruction “call appeU” which is a call to a subroutine "calli” and on the other hand, the instruction “inc a” which is an instruction of incrementation of a variable .
  • the jump instruction “jz etiq” (meaning “jump if the result of the previous instruction is equal to 0") is downstream of these two instructions to be preserved.
  • FIG. 10 obtained from the example of FIG.
  • the nonoperating batch inserted between the instruction to be preserved and the jump instruction may not contain an eject instruction. Indeed if an attacker reaches an instruction of this lot then the execution of the program will return by the instruction of jump and thus by the test preceding this instruction, instruction "and", which ensures that this jump instruction will be re-executed thus ensuring the security of the program.
  • FIG. 10 shows that in order to preserve this instruction, a nonoperating batch is inserted between the jump instruction and the instruction to be preserved, also shown in FIG. 4.
  • this non-operating batch must, preferably, comprise an ejection instruction preventing the execution of instructions downstream of this batch.
  • Figure 11 shows another example of an assembler program, where it is presented the case of an unconditional jumping instruction "jump”, preceding the following instructions to preserve: "call appeU” and "inc a”.
  • FIG. 12 obtained from FIG. 11 illustrates the security of the assembler program of FIG. 11. Concerning the instructions to be preserved following "call-call 1" and "inc a”, they are located downstream of the address targeted by FIG. jump instruction "etiq 2". In order to secure these instructions as shown in FIG. 6, non-operating batches are inserted between the address targeted by the jump instruction and the instructions to be preserved, causing the output of these instructions from the zone accessible to the user. jump instruction. These instructions are now not directly accessible by the jump instruction.
  • the example of FIG. 11 includes possibly sensitive instructions, for example the "call-call2" instruction, which are not protected by non-operative batches.
  • after securing the memory zone by insertion of non-operative batches it comprises at least 90% non-operating instructions
  • an attacker may attempt to disrupt the jump instruction to prevent the execution of an abnormality processing program.
  • the attacker can, for example, execute the code of reading data in memory and retrieve this data fraudulently. For example, the attacker can skip the instruction "CaIIiere_anomalie", call that takes place when the computation and checksum verification are invalid, these operations must take place before the related data are sent to the terminal in which is inserted the smart card to verify their integrity.
  • the term "alternative instructions” means the instructions constituting an alternative to the execution of the instructions located at the address targeted by the conditional jump instruction.
  • the alternative instructions further include the instruction to preserve "call suite_prog", whose role is the normal continuation of the program. This instruction is located after the jump instruction and is accessible by the jump instruction. For example, this statement is the first statement after this jump statement.
  • the alternative instructions contain the instruction to be preserved followed by a non-operative batch extending to the end of the memory zone, for example, as a particular case of FIG.
  • the security batch containing the anomaly processing is located substantially in the last addresses of the memory area accessible by the jump instruction.
  • the nonoperating batch is inserted in such a way that the security batch starts at the last accessible instruction of this memory zone. This provides optimal protection for the memory area immediately following the jump instruction.
  • This implementation can also be performed in the memory area before the jump instruction.
  • the safe lot is just before the jump instruction and any test instruction that conditions the jump, and the insertion of the nonoperating batch is such that the instruction to be preserved is at the beginning of the memory zone. .
  • the alternative instructions comprise the security batch.
  • the security lot precedes the instruction to be preserved.
  • a non-operative instruction batch is inserted after the jump instruction and upstream of the safe batch.
  • the nonoperating batch is placed immediately after the jump instruction.
  • this non-operating lot is followed first of all by the alternative instruction (the security lot) and then by the instruction to be preserved, which must remain accessible by the address targeted by the jump instruction. the jump instruction that aims to achieve this instruction to preserve.
  • an optimal protection for the memory area according to the jump instruction is also obtained, since the probability of executing the instruction to be preserved is minimized and the probability of executing the security batch is maximized, for example, following a fault attack.
  • This implementation can also be performed in the memory area before the jump instruction.
  • the jump instruction is such that it allows only to jump forward. In this way optimal protection is obtained by virtue of the invention as illustrated in FIGS. 15 and 16. Indeed, there is no risk that, in the event of an attack, the jump reaches an instruction preceding the instruction. of jump.
  • a new conditional jump instruction can be envisaged, this instruction having as parameters two jump relative addresses.
  • Known conditional statements such as "jz" or "jnz” have a parameter indicating a relative jump address.
  • These instructions have two functional outputs. Indeed, these instructions perform a jump to the relative address if the result of the previous instruction is respectively equal to 0 or not equal to 0, otherwise the execution continues at the address following the jump instruction.
  • the new jump instruction comprises two relative addresses, so that this instruction jumps to the first relative address if the result of the preceding instruction is, for example, equal to 0, or a jump to the second relative address in the opposite case.
  • a program including this new instruction can be secured by adding non-operative instruction batches and safe instruction batches, for example, before the first hop address, before the second hop address.

Landscapes

  • Engineering & Computer Science (AREA)
  • Computer Security & Cryptography (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Computer Hardware Design (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Executing Machine-Instructions (AREA)
  • Storage Device Security (AREA)

Abstract

Un procédé pour sécuriser un programme contre des attaques par faute, notamment dans une carte à puce, selon lequel, on identifie dans ce programme au moins une instruction de saut comportant une adresse relative choisie parmi une pluralité d'adresses relatives possibles, ladite au moins une instruction de saut permettant d'atteindre une adresse visée au sein d'une zone mémoire s'étendant avant et après cette instruction de saut et regroupant cette pluralité d'adresses relatives possibles, au sein de cette zone mémoire, on identifie une instruction à préserver et, pour sécuriser au moins cette instruction, on insère au moins un premier lot non opérant comportant au moins une instruction, cette insertion étant réalisée de telle sorte que cette insertion est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire, et cette insertion est compatible avec le déroulement normal du programme.

Description

PROTECTION CONTRE LES ATTAQUES PAR GENERATION DE FAUTES SUR LES INSTRUCTIONS DE SAUT
La présente invention se rapporte à un procédé de sécurisation d'un programme informatique et à un dispositif, notamment une carte à microcircuit (aussi appelée "carte à puce") mettant en œuvre un tel procédé. L'invention concerne également un dispositif de génération de la sécurisation d'un programme associé à ce procédé.
Dans la suite de ce document, on entendra par « sécurisation » d'un programme informatique :
- la détection d'attaques mal intentionnées visant à perturber le comportement normal d'un programme informatique ; mais aussi - tout traitement visant à fiabiliser le déroulement d'un programme informatique et notamment celui d'un programme s'exécutant dans un environnement très perturbé, comme un satellite, ou celui d'un programme informatique à forte exigence de fiabilité comme par exemple un programme de contrôle d'un implant cardiaque. Par ailleurs, on entendra par programme informatique, tout programme, quel que soit le langage informatique et les moyens de mémorisation utilisés. Par exemple, et de façon non limitative, le programme informatique peut être écrit en langage machine, assembleur, C, C++, Java, VHDL. Le programme peut être mémorisé dans une mémoire permanente, par exemple dans une mémoire ROM ou EEPROM ou sur un disque dur, ou dans une mémoire volatile, par exemple de type RAM. Le programme peut être également matérialisé par un circuit intégré, par exemple de type FPGA ou même d'un circuit ASIC (Application Spécifie Integrated Circuit).
La présente invention vise en particulier la détection d'une attaque destinée à modifier le déroulement de l'exécution d'un programme informatique s'exécutant sur une entité électronique sécurisée, par exemple une carte à microcircuit, une carte PCMCIA sécurisée (par exemple une carte IBM4758), une clef USB ou un passeport intégrant une puce sans contact dans une de ses pages, et le déclenchement d'une contre-mesure à cette attaque.
La présente invention vise tout particulièrement à détecter des attaques par perturbation du fonctionnement d'une entité électronique, par exemple les attaques de type « attaques par génération de fautes » (en anglais "Fault Attack").
Ces attaques visent à modifier illicitement le contenu ou la lecture du contenu d'un registre, d'une mémoire ou d'un bus, ou à obliger un processeur à ne pas ou mal exécuter certaines instructions d'un programme informatique. Le programme informatique attaqué peut alors se dérouler d'une façon très différente de celle qui avait été prévue au moment de sa conception.
Ces attaques peuvent, entre autres et de façon connue, être effectuées : - en générant un pic de tension à l'une des bornes d'alimentation du processeur ;
- en élevant brusquement sa température;
- en changeant rapidement sa fréquence d'horloge ou sa tension d'alimentation ; - en appliquant un flash de lumière, un rayon laser, ou un champ électromagnétique, sur une partie du silicium qui le compose.
De telles attaques sont particulièrement actives sur certaines instructions d'un programme, notamment les instructions de branchements conditionnels et inconditionnels. On rappellera à cet effet que les instructions de branchement sont par exemple les instructions « if », « case », en langage C. La compilation de telles instructions de branchement en langage assembleur produit une instruction de saut conditionnel ou inconditionnel vers une adresse ou une instruction du programme à atteindre. L'instruction à atteindre est repérée par une étiquette dans un programme en assembleur. Selon le langage assembleur 8051 , les instructions de saut conditionnels ou inconditionnels du langage C sont traduites en instructions de type « jnz » (qui peut être traduit par « saut si le résultat de l'instruction précédente est non égal à 0 »), « jz » (que l'on peut traduire par « saut si le résultat de l'instruction précédente est égal à 0 »), « jmp » (qui peut être traduit par « saut »).
Une fois compilée en langage machine, l'instruction à atteindre est identifiée par son adresse passée en argument (ou paramètre) de l'instruction de saut. Cette adresse est soit un incrément ou un décrément en nombre d'octets par rapport à l'adresse de l'instruction de saut, encore appelée adresse relative, soit une adresse absolue, c'est-à-dire, une adresse fixe au sein de la mémoire. Les instructions de saut comportent le plus souvent une adresse relative de saut.
L'adresse relative représente la différence d'octets entre l'adresse de l'instruction à atteindre et l'adresse de l'instruction de saut.
Lors d'une attaque par faute, l'exécution d'une instruction de saut peut dans une très grande majorité des cas être perturbée, lors par exemple, d'une attaque par faute, entraînant un saut vers une adresse non prévue par le programme initial. En effet, lors de la perturbation d'une telle instruction, le résultat obtenu est équivalent à une modification de la valeur de l'adresse passée en argument de l'instruction de saut. Cette valeur est modifiée de manière aléatoire. Ainsi si l'adresse du saut est une adresse relative, l'adresse qui serait atteinte par l'instruction de saut ainsi perturbée, serait une adresse comprise dans l'ensemble des adresses accessibles à partir de l'adresse de saut.
Ainsi, par exemple, lorsque l'adresse relative passée en argument de l'instruction de saut est codée sur un octet, soit 8 éléments binaires, une attaque par faute de cette adresse provoque un saut dans une zone mémoire comprise entre - (27 - 1 ) et 27 - 1 octets soit entre -127 et +127 octets par rapport à l'adresse de l'instruction de saut. L'adresse atteinte par le saut suite à l'attaque par génération de faute est équiprobable sur cet intervalle. Selon le langage assembleur utilisé, l'adresse relative peut aussi être codée sur 2 ou 3 octets voire plus, dans une zone mémoire d'autant plus importante.
Etant donné que les instructions sont codées et mémorisées, par exemple sur 2 ou 3 octets, la zone d'instructions précédant et suivant l'instruction de saut définie par l'adresse relative, se compose donc typiquement d'une centaine d'instructions au maximum.
La modification de l'adresse résultante du saut peut entraîner l'accès de façon non autorisée à une instruction critique du programme ou à des données sensibles, par exemple des clés et donc permettre à un attaquant la mise en péril de la sécurité du système.
Selon l'état actuel de la technique, l'homme du métier dispose de différents moyens pour sécuriser un programme informatique et notamment pour lutter contre les attaques par génération de fautes dans une carte à microcircuit.
Une méthode consiste à installer, dans les composants des cartes à microcircuit, des capteurs qui permettent de détecter de telles attaques.
L'efficacité d'une telle méthode est néanmoins restreinte car il est en pratique impossible de mettre des capteurs sur toute la surface de ce composant. Par ailleurs ces capteurs étant également composés de silicium, il est également possible de les perturber ou de modifier les informations qu'ils transmettent.
La présente invention vise une méthode de sécurisation de type logiciel et ne présentant pas les inconvénients précédents. A cet effet, elle propose un procédé de sécurisation d'un programme informatique contre des attaques par faute. Ce procédé est applicable notamment dans une carte à puce. Selon ce procédé, on identifie dans le programme au moins une instruction de saut comportant une adresse relative choisie parmi une pluralité d'adresses relatives possibles, et permettant d'atteindre une adresse visée au sein d'une zone mémoire s'étendant avant et après de cette instruction de saut et regroupant cette pluralité d'adresses relatives possibles. Au sein de cette zone mémoire, on identifie une instruction à préserver. Pour sécuriser au moins cette instruction, on insère au moins un premier lot non opérant comportant au moins une instruction, cette insertion étant réalisée de telle sorte que :
- cette insertion est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire,
- cette insertion est compatible avec le déroulement normal du programme.
Le procédé de sécurisation selon l'invention consiste donc à insérer une ou plusieurs instructions au sein de la zone mémoire s'étendant en amont et en aval de l'instruction de saut, et comprenant toutes les adresses accessibles à partir de l'adresse relative visée par l'instruction de saut, soit une zone mémoire allant de -127 octets à +127 octets lorsque cette adresse relative est codée sur un octet.
Ainsi, la sécurité de l'instruction à préserver est accrue. En effet, lors d'une attaque par faute générant une modification de l'adresse relative atteinte par l'instruction de saut, l'instruction à préserver a moins de chance d'être atteinte, et donc, cette instruction a moins de chance d'être exécutée à un moment où cela n'est pas prévu, tandis que les instructions insérés sont privilégiées. Les instructions insérées forment un lot, et ce lot est non opérant, c'est-à-dire qu'il ne modifie pas le comportement fonctionnel du programme lors d'une exécution normale du programme. Les instructions composant un lot sont notamment, l'instruction vide (par exemple en assembleur l'instruction « nop » signifiant « non opérant »), ou une instruction n'ayant aucun effet sur le résultat de l'exécution du programme à elle seule ou combinée avec d'autres instructions en fonctionnement normal.
Lors d'une attaque ou d'une perturbation de l'exécution, selon l'invention, on a une certaine probabilité de tomber dans les lots non opérant.
L'insertion du lot non opérant peut impliquer une modification de l'argument de l'instruction de saut pour atteindre l'adresse visée. Cependant, l'insertion de lot non opérant doit être compatible avec le maintien de cette adresse visée par l'instruction de saut à l'intérieur de la zone mémoire précédemment définie.
En plus d'instructions à préserver, le programme peut comporter des instructions qui sont au contraire à favoriser pour la sécurité du déroulement du programme. En particulier, après un test, les instructions à effectuer en cas de test valide sont généralement à préserver tandis que les instructions en cas de test invalide sont souvent à favoriser. C'est pourquoi, selon un mode de réalisation particulier, le procédé comprend les étapes suivantes : identification dans le programme d'un lot sécuritaire comportant au moins une instruction à exécuter, insertion d'un lot non opérant, distinct ou non du premier lot opérant, précédant le lot sécuritaire identifié et propre à en favoriser l'exécution. Ce mode de réalisation implique donc, d'une part d'identifier un lot sécuritaire, c'est-à-dire un ensemble d'instructions réalisant une action sensible, dont la non exécution peut mettre en péril la sécurisation du système, puis, d'autre part, de favoriser l'exécution du lot sécuritaire identifié, étant donné que ce lot doit être exécuté pour la sécurité du programme et de la carte, en insérant précédemment à ce lot un lot non opérant qui améliore la probabilité d'exécuter ce lot sécuritaire. Ainsi en cas de fautes, une instruction de saut peut atteindre ce lot non opérant qui va forcer l'exécution les instructions du lot sécuritaire, assurant ainsi que ce lot est exécuté.
La nature du premier lot non opérant peut dépendre des positions relatives de l'instruction de saut, de l'adresse visée par le saut et de l'instruction à préserver.
Lorsqu'on ne veut pas avoir à tenir compte de ces positions relatives, dans un premier mode de réalisation, le premier lot non opérant est inséré dans le programme de manière à ce qu'une instruction de contournement empêche normalement l'exécution des instructions du lot non opérant et qu'une instruction d'éjection vers un programme d'action, à la fin du lot non opérant, empêche l'exécution d'instructions en aval de ce lot non opérant.
Ce mode de réalisation est particulièrement avantageux car en fonctionnement normal du programme ou lorsque l'instruction de saut atteint normalement une instruction en amont du lot non opérant inséré, une instruction de contournement empêche l'exécution d'instructions de ce lot non opérant.
En effet, en l'absence d'instruction de type saut, appel de sous programme ou de type retour au programme appelant (instruction assembleur « ret », en anglais « return ») précédant le premier lot non opérant, ce lot serait atteint. La présence d'une instruction de contournement évite un tel inconvénient.
Ainsi, de manière avantageuse, lors d'un fonctionnement normal du programme, ce lot non opérant d'instructions inséré n'est pas exécuté, et donc les performances du programme (performances modifiées, induites par l'ajout de lot d'instructions) ne sont quasiment pas modifiées.
De plus, une instruction d'éjection située sensiblement à la fin du lot non opérant inséré est présente de telle sorte que, dans le cas d'une perturbation de l'instruction de saut, le saut atteigne ce premier lot non opérant d'instructions, cette instruction d'éjection empêche l'exécution d'instructions en aval du lot non opérant et donc empêche l'exécution de l'instruction à préserver si celle-ci est en aval de ce lot. Dans ce cas, la sécurité du système est grandement augmentée puisque ce lot non opérant, exécuté en cas de faute, évite d'atteindre l'instruction à préserver et exécuter cette instruction à préserver à un moment où cela n'est pas prévu. En fait, même lorsque ce lot non opérant n'est pas inséré avant l'instruction à préserver, la sécurité est améliorée par le simple fait qu'il y a éjection si le saut aboutit, suite à une par perturbation, dans ce lot non opérant.
Selon une caractéristique avantageuse, le programme d'action comprend un lot sécuritaire comportant au moins une instruction à exécuter.
En effet, selon un mode d'exécution particulier, le programme d'action comprend des instructions dont l'exécution doit être réalisée pour la sécurité du programme. Ainsi, la sécurisation du programme est sensiblement améliorée du fait que l'on augmente, en cas de perturbation, la probabilité d'exécuter un lot sécuritaire comprenant une suite d'instructions importantes pour la sécurité du programme. Selon une première variante de réalisation, l'instruction de contournement fait partie du programme à sécuriser et précède le lot non opérant de telle sorte que ce lot non opérant n'est normalement pas exécuté.
Selon une seconde variante de ce mode de réalisation, l'instruction de contournement est au début du lot non opérant et renvoie vers la première instruction du programme en aval de ce lot non opérant.
Dans ce cas, le lot non opérant peut être inséré en aval d'une instruction quelconque de programme, la première instruction de ce lot (instruction de contournement) renvoyant vers cette instruction.
Il mérite d'être noté que les différents modes de réalisation empêchant l'exécution de lots non opérant limitent les pertes de performances potentielles dues à l'insertion de code.
Certaines règles de positionnement du premier lot non opérant peuvent être avantageuses et permettre une simplification de la structure de ce lot. C'est ainsi que, de manière préférée, l'insertion du premier lot non opérant est effectuée après la première des dites instructions de saut ou à préserver.
Cette caractéristique contribue avantageusement à la sécurisation d'un programme ainsi que cela apparaît ci-dessous.
Selon un premier mode de réalisation du procédé de sécurisation, l'insertion du lot non opérant est effectuée entre l'instruction à préserver et l'instruction de saut si cette instruction à préserver précède l'instruction de saut.
Cette caractéristique est particulièrement avantageuse, en effet elle a pour fonction d'éloigner l'instruction à préserver de l'instruction de saut par insertion de lots entre les deux instructions, et de remonter cette instruction à préserver au sein de la zone mémoire accessible à partir de l'adresse de l'instruction de saut et précédant l'instruction de saut. L'instruction à préserver étant remontée au sein de la zone mémoire précédant l'instruction de saut, en cas de perturbation de l'adresse relative du saut, les chances d'exécuter cette instruction se trouvent diminuées malgré le fait que les adresses sont accessibles de manière équiprobable. En effet, lors d'un saut, l'exécution se poursuit en incrémentant l'adresse des instructions, la probabilité d'exécuter l'instruction à préserver après insertion de lot non opérant s'en trouve diminuée. Avantageusement, lorsque, en outre, l'instruction à préserver précède l'adresse visée par l'instruction de saut, le lot non opérant comporte un nombre d'instructions tel que, après insertion, l'instruction à préserver est en amont de la zone mémoire accessible par l'instruction de saut.
Préférentiellement, le lot non opérant comprend au minimum m instructions avec m = 2n"1 + l'adresse relative (avant sécurisation) de l'instruction à préserver par rapport à l'instruction de saut, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée.
Ainsi, l'insertion du lot non opérant est effectuée de telle sorte que celle-ci entraîne la sortie de l'instruction à préserver de la zone mémoire précédant l'instruction de saut, rendant son accès impossible à partir de l'instruction de saut.
De manière alternative, lorsque l'adresse visée par l'instruction de saut précède l'instruction à préserver, alors le lot non opérant comprend au maximum p instructions avec p = 2n"1 -1 + l'adresse relative (avant sécurisation) visée par l'instruction de saut, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, grâce à quoi l'instruction cible reste dans la zone mémoire après sécurisation.
En effet, afin de respecter la contrainte que l'insertion doit être compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire précédant l'adresse de saut, lorsque l'instruction à préserver est présente dans la zone définie par l'adresse de saut de l'instruction de saut et l'instruction de saut, alors le nombre d'instructions que contient le lot non opérant est limité de manière à ne pas faire sortir l'instruction présente à l'adresse visée par l'instruction de saut. Préférentiellement, le lot non opérant est inséré de manière à n'être exécuté qu'en cas de perturbation de l'instruction de saut, une instruction de contoumement empêchant normalement l'exécution d'instructions de ce lot non opérant.
Ainsi de manière avantageuse, lors d'un fonctionnement normal du programme, ce lot non opérant d'instructions inséré n'est pas exécuté, et donc Ia perturbation en termes de performance du programme, perturbation de performance induite par l'ajout de lot d'instructions, s'en trouve très limitée.
De manière avantageuse, ce lot comporte également à la fin du lot non opérant, une instruction d'éjection empêchant l'exécution d'instructions en aval de ce lot non opérant. Cette instruction est présente de telle sorte que, dans le cas d'une perturbation de l'instruction de saut, le saut atteint un lot non opérant d'instructions, une instruction d'éjection empêche l'exécution d'instructions en aval du lot non opérant et donc empêche l'exécution de l'instruction en aval du lot non opérant. Selon un second mode de réalisation du procédé de sécurisation, l'insertion de lot non opérant est effectuée entre l'instruction de saut et l'instruction à préserver de manière à n'être exécuté qu'en cas de perturbation de l'instruction de saut, et une instruction d'éjection à la fin du lot non opérant empêche l'exécution d'instructions en aval de ce lot non opérant. Ainsi, lorsque l'insertion de lot non opérant s'effectue en aval de l'instruction de saut et que cette dernière précède l'instruction à préserver, alors cette insertion permet de repousser l'instruction à préserver vers l'extérieur de la zone mémoire suivant l'instruction de saut. Le risque qu'après perturbation de l'adresse de l'instruction de saut, cette instruction atteigne une instruction à préserver est donc diminué.
Avantageusement, lors d'insertion de lot entre l'instruction de saut et l'instruction à préserver, ce lot doit contenir au minimum une instruction d'éjection. Cette dernière permet en cas de perturbation de l'instruction de saut, le saut atteignant ce lot, d'empêcher l'exécution d'instructions en aval de ce lot et donc de l'instruction à préserver. Préférentiellement, le lot non opérant est inséré juste en amont l'adresse visée par l'instruction de saut lorsque l'adresse visée par l'instruction de saut est en amont de l'instruction à préserver.
Ainsi de manière avantageuse, lors d'un fonctionnement normal du programme, ce lot non opérant d'instructions inséré n'est pas exécuté, et donc la perturbation en termes de performance du programme, perturbation de performance induite par l'ajout de lot d'instructions, s'en trouve très limitée.
Selon une variante de réalisation, une instruction de contoumement empêche normalement l'exécution d'instructions du lot non opérant.
Préférentiellement, l'instruction de contoumement est au début du lot non opérant, et renvoie vers la première instruction du programme en aval de ce lot non opérant.
Avantageusement, selon ces modes de réalisation, le lot non opérant peut être inséré en aval d'une instruction de programme, quelque soit cette instruction de programme. Ainsi afin de ne pas exécuter en fonctionnement normal le lot non opérant inséré et donc arriver sur une instruction d'éjection, la première instruction de ce lot est une instruction de contoumement de ce lot renvoyant vers la première instruction en aval de ce lot.
De plus, les différents modes de réalisation empêchent l'exécution de lots non opérant et donc limitent les pertes de performances potentielles dues à l'insertion de code.
Avantageusement, lorsque l'instruction à préserver précède l'adresse visée par l'instruction de saut, le lot non opérant comprend au maximum q instructions avec q = 2n"1 -1 - adresse relative visée par l'instruction de saut, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, grâce à quoi l'instruction cible reste dans la zone mémoire après sécurisation. En effet, afin de préserver la contrainte telle que l'insertion est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire, le nombre d'instructions non opérantes susceptibles d'être ajoutées est limité.
Ainsi, il n'est nullement possible de repousser l'instruction visée par l'instruction de saut en dehors de la zone mémoire suivant l'instruction de saut.
L'effet de la sécurisation est atteint, en cas d'erreur. Or cet effet est d'autant plus probable que la taille du lot non opérant est importante.
Dans l'alternative où la première instruction est l'instruction de saut et que l'adresse visée par l'instruction de saut précède l'instruction à préserver, le lot non opérant est inséré entre l'adresse visée par l'instruction de saut et l'instruction à préserver.
L'insertion de lots non opérant entre l'adresse visée par l'instruction de saut et l'instruction à préserver, permet de repousser l'instruction à préserver à l'extérieur de la zone mémoire accessible après l'instruction de saut.
Selon une caractéristique, l'instruction à préserver est à la fin de la zone mémoire après l'instruction de saut.
De manière préférentielle, le lot non opérant comporte un nombre d'instructions tel que après insertion, l'instruction à préserver est en aval de la zone mémoire.
Ainsi, l'insertion de lot entraîne la sortie de l'instruction à préserver de la zone mémoire précédant l'instruction de saut, rendant son accès impossible à partir de l'instruction de saut.
Selon ce mode de réalisation, le lot non opérant comprend au minimum r instructions, avec r = 2n"1 - l'adresse relative de l'instruction à préserver par rapport à l'instruction de saut, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée.
Selon une troisième variante de réalisation, l'insertion est effectuée après la seconde des dites instructions du programme de manière à ce qu'une instruction de contoumement empêche normalement l'exécution des instructions du lot et qu'une instruction d'éjection à la fin du lot empêche l'exécution d'instructions en aval de ce lot. Préférentiellement l'instruction de contournement fait partie du programme à sécuriser et précède le lot non opérant de telle sorte que ce lot non opérant n'est normalement pas exécuté.
Alternativement, l'instruction de contournement est au début du lot non opérant renvoyant vers la première instruction du programme en aval de ce lot non opérant.
Avantageusement, selon ces modes de réalisation, le lot non opérant peut être inséré en aval d'une instruction de programme, quelque soit cette instruction de programme. Ainsi afin de ne pas exécuter en fonctionnement normal, le lot non opérant inséré et donc arriver sur une instruction d'éjection, la première instruction de ce lot est une instruction de contournement de ce lot renvoyant vers la première instruction en aval de ce lot.
De plus, les différents modes de réalisation empêchent l'exécution de lots non opérant et donc limite les pertes de performances potentiels dues à l'insertion de code.
Selon une caractéristique, l'instruction à préserver précédant le lot sécuritaire, l'instruction à préserver et le lot sécuritaire étant du même côté par rapport à l'instruction de saut, l'insertion du lot non opérant est effectuée entre l'instruction à préserver et le lot sécuritaire.
Ainsi, lorsque l'on souhaite davantage favoriser le lot sécuritaire que de protéger l'instruction à préserver, l'insertion du lot non opérant est effectuée de manière à conduire l'exécution du programme vers le lot sécuritaire en cas d'attaque. Selon cette méthode, l'exécution du lot sécuritaire est favorisée, toutefois, en préservant l'instruction à préserver
Plus particulièrement, lorsque l'instruction à préserver est juste après l'instruction de saut, alors l'insertion du lot non opérant est tel que Ie lot sécuritaire est à la fin de la zone mémoire.
De cette manière, la zone mémoire suivant l'instruction de saut comprend l'instruction à préserver juste après l'instruction de saut, puis la zone mémoire est remplie d'un ensemble d'instructions non opérantes formant un lot non opérant, de tel sorte que le lot sécuritaire est à la fin de la zone mémoire. Alternativement, lorsque le lot sécuritaire est juste avant l'instruction de saut, alors l'insertion du lot non opérant est telle que l'instruction à préserver est au début de la zone mémoire.
Selon une autre caractéristique, le lot sécuritaire précède l'instruction à préserver, le lot sécuritaire et l'instruction à préserver sont du même côté par rapport à l'instruction de saut, l'insertion du lot non opérant est en amont du lot sécuritaire et est effectuée du même côté que le lot sécuritaire par rapport à l'instruction de saut.
Ainsi, lorsque l'on souhaite davantage favoriser le lot sécuritaire que de protéger l'instruction à préserver, alors l'insertion du lot non opérant est effectuée de manière à conduire l'exécution du programme vers le lot sécuritaire en cas d'attaque. Selon cette méthode, l'exécution du lot sécuritaire est favorisée, toutefois, en préservant l'instruction à préserver.
Plus particulièrement, l'insertion du lot non opérant est telle que l'instruction à préserver est à la fin de la zone mémoire.
Selon un mode particulier de réalisation de l'invention, après insertion d'un lot non opérant, on identifie au sein de cette zone mémoire au moins une autre instruction à préserver et, pour sécuriser cette autre instruction, on insère un autre lot non opérant comportant au moins une instruction, cette instruction étant exécutée en respectant les dites conditions.
Selon un autre mode de réalisation de l'invention, avant insertion d'un lot non opérant, on identifie au sein de cette zone mémoire au moins une autre instruction à préserver, et on insère le lot non opérant de sorte à respecter les conditions vis-à-vis de chacune des instructions à préserver. Avantageusement, après sécurisation de la zone mémoire s'étendant avant et après l'instruction de saut, cette zone mémoire comporte au moins 90% d'instructions faisant parties de lots non opérant insérés.
Ainsi la dite zone mémoire comportant au moins 90% d'instructions issues de lots non opérant insérés, on maximise la probabilité suite à une perturbation d'atteindre une instruction d'un lot non opérant, limitant ainsi le risque d'atteindre une instruction à préserver. Selon un mode de réalisation, un lot non opérant comprend une pluralité d'instructions.
Selon une variante de l'invention, le lot non opérant comprend au moins une instruction d'éjection vers un programme d'action. Ce mode de réalisation permet non pas de limiter les effets d'une perturbation mais également de détecter ces perturbations et de lancer des programmes d'action dans le but de contrer des attaques ou de fiabiliser le déroulement d'un programme.
De manière alternative, le lot non opérant inséré comprend au moins une instruction d'éjection vers un sous programme d'action.
Selon une caractéristique, le programme d'action comprend un lot sécuritaire comportant au moins une instruction à exécuter.
En effet, selon un mode d'exécution particulier, le programme d'action comprend des instructions dont leur exécution doit être réalisée pour la sécurité du programme. Ainsi, la sécurisation du programme est sensiblement améliorée du fait que l'on augmente, en cas de perturbation, la probabilité d'exécuter une suite d'instructions importantes pour la sécurisation du programme.
Avantageusement le programme d'action comprend des instructions de fin prématurée d'exécution du programme.
Selon ce mode de réalisation, le programme a détecté une attaque ou une perturbation lors de l'exécution, ce qui entraîne la fin de l'exécution du programme.
De manière alternative, le programme d'action comprend des instructions de réinitialisation de l'exécution du programme.
L'invention concerne également un procédé d'exécution sécurisé d'un programme contre des attaques par faute, notamment dans une carte à puce. Le procédé met en œuvre une étape de sécurisation du programme selon l'invention préalablement à l'exécution dudit programme. Corrélativement, l'invention concerne un dispositif de sécurisation d'un programme comprenant un moyen pour identifier dans ce programme au moins une instruction de saut comportant une adresse relative choisie parmi une pluralité d'adresses relatives possibles, et permettant d'atteindre une adresse au sein d'une zone mémoire s'étendant avant et après cette instruction de saut et regroupant toutes les adresses accessibles à partir de l'adresse relative, un moyen pour identifier une instruction à préserver au sein de la zone mémoire et, un moyen pour insérer au moins un lot non opérant comportant au moins une instruction pour sécuriser au moins cette instruction.
Ce dispositif présente les mêmes avantages que le procédé de sécurisation d'un programme contre des attaques par faute brièvement décrit ci-dessus. L'invention vise aussi un support d'informations lisible par un système informatique, éventuellement totalement ou partiellement amovible, notamment CD-ROM ou support magnétique, tel un disque dur ou une disquette, ou support transmissible tel un signal électrique ou optique, ce support d'informations comportant des instructions d'un programme informatique permettant la mise en œuvre d'un procédé de sécurisation tel que décrit brièvement ci-dessus, lorsque ce programme est chargé et exécuté par un système informatique.
L'invention vise également un programme d'ordinateur stocké sur un support d'informations, ce programme comportant des instructions permettant la mise en œuvre d'un procédé de sécurisation tel que décrit ' brièvement ci-dessus, lorsque ce programme est chargé et exécuté par un système informatique.
Les avantages et caractéristiques particulières propres aux support d'information, au programme d'ordinateur et à la carte à microcircuit étant les mêmes que ceux exposés ci-dessus concernant le procédé de sécurisation selon l'invention, ils ne seront pas rappelés ici.
D'autres aspects et avantages de la présente invention apparaîtront plus clairement à la lecture de la description de modes particuliers de réalisation qui va suivre, cette description étant donnée uniquement à titre d'exemple non limitatif, en regard des dessins annexés sur lesquels : - La figure 1 est un schéma de principe du procédé de sécurisation selon l'invention, dans un cas où l'instruction à préserver précède l'instruction de saut.
- La figure 2 est un cas particulier de la figure 1 où l'instruction à préserver précède en outre l'adresse visée par l'instruction de saut.
- La figure 3 est un autre cas particulier de la figure 1 où par contre, l'adresse visée par l'instruction de saut précède l'instruction à préserver.
- La figure 4 est un schéma de principe du procédé de sécurisation selon l'invention, dans un cas où l'instruction de saut précède l'instruction à préserver.
- La figure 5 est un autre cas particulier de la figure 4 où l'instruction à préserver précède l'adresse visée par l'instruction de saut.
- La figure 6 est un autre cas particulier de la figure 4 où l'adresse visée par l'instruction de saut précède l'instruction à préserver.
- La figure 7 est un troisième schéma de principe du procédé de sécurisation selon l'invention, dans un cas où l'instruction de saut précède l'instruction à préserver.
- La figure 8 est un second schéma de principe du procédé de sécurisation selon l'invention, dans un cas où l'instruction de saut précède l'instruction à préserver.
- La figure 9 est un exemple de programme informatique susceptible d'être sécurisé par un procédé de sécurisation conforme à la présente invention. - La figure 10 est le code assembleur obtenu après exécution du procédé de sécurisation selon l'invention sur l'exemple de la figure 9.
- La figure 11 est un second exemple de programme informatique susceptible d'être sécurisé par un procédé de sécurisation conforme à la présente invention. - La figure 12 est le code assembleur après exécution du procédé de sécurisation selon l'invention sur l'exemple de la figure 11 de telle sorte que l'instruction à préserver se trouve en amont de la zone mémoire accessible par l'instruction de saut.
- La figure 13 est un troisième exemple de programme informatique susceptible d'être sécurisé par un procédé de sécurisation conforme à la présente invention.
- La figure 14 est le code assembleur après exécution du procédé de sécurisation selon l'invention sur l'exemple de la figure 13 de telle sorte que les instructions insérées comprennent une instruction de contournement et une instruction d'éjection. - La figure 15 est le code assembleur après exécution du procédé de sécurisation selon l'invention appliqué avec une instruction de saut conditionnel.
- La figure 16 est une alternative de code assembleur après exécution du procédé de sécurisation selon l'invention appliqué avec une instruction de saut conditionnel.
On peut généralement identifier dans un programme des instructions à préserver, à n'exécuter qu'à bon escient, et des instructions à favoriser, dont l'exécution contribue à la fiabilité du programme. C'est ainsi, notamment, que les instructions à exécuter après vérification de divers tests peuvent souvent être considérées comme des instructions sensibles qu'il vaut mieux préserver, tandis que les instructions de correction, à exécuter lorsque les tests sont négatifs, peuvent souvent être considérées comme des instructions sécuritaires qu'il vaut mieux favoriser. On peut noter ainsi qu'après un test, on peut généralement identifier une alternative entre une instruction à préserver et une instruction à favoriser et que le fait de réduire les chances que l'instruction à préserver soit exécutée en cas de perturbation ou de perturbation du saut revient souvent à augmenter la probabilité d'exécuter d'autres instructions. Pour ce faire, on peut insérer dans le programme de départ un lot non opérant qui est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire accessible et qui ne perturbe pas le déroulement normal du programme.
Une solution générale consiste, en un quelconque endroit, à insérer un lot commençant par une instruction de contournement qui envoie vers l'instruction suivant ce saut et se terminant par une instruction d'éjection vers un programme ou sous-programme d'action (réinitialisation, répétition du test, tests complémentaires, etc, voire destruction de la carte).
Un tel lot agit ainsi comme un piège détectant des résultats erronés de saut, notamment des résultats d'un saut perturbé par une attaque. Toutefois divers cas particuliers peuvent être identifiés qui améliorent spécifiquement la préservation de l'instruction à préserver (en favorisant éventuellement des instructions sécuritaires) et / ou simplifient la constitution des lots non opérants. Les cas particuliers peuvent être définis en référence aux positions relatives de l'instruction à préserver et de l'instruction de saut, voire de l'adresse visée par le saut.
Il importe ici de noter qu'il peut y avoir un choix arbitraire des instructions de saut et des instructions à préserver (ou a contrario des instructions à favoriser) et que, dans un programme donné, on peut choisir de ne pas sécuriser tous les sauts relatifs ni de préserver toutes les instructions sensibles.
En référence à la figure 1 , il est montré un schéma de principe selon l'invention, dans lequel une instruction de saut est suivie d'une adresse relative permettant lors de son exécution d'atteindre une adresse mémoire représentée. L'adresse passée en argument de l'instruction de saut est une adresse relative codée sur n éléments binaires. Par exemple, le nombre d'éléments binaires est 8 représentant un octet. Cette instruction permet d'exécuter un saut dans une mémoire allant de -(2n"1 -1 ) à 2π"1 -1. Selon l'exemple considéré, la zone mémoire accessible par l'instruction de saut va de -127 à + 127 octets.
Dans cette zone mémoire, il est identifié au moins une instruction à préserver. Une instruction à préserver est identifiée comme une instruction dangereuse pour la sécurité du système si elle est exécutée à un moment où cela n'est pas prévu. Ainsi une instruction à sécuriser peut se définir comme étant soit une instruction à exécuter seulement au moment opportun, soit une instruction à exécuter obligatoirement à un moment donné au cours de l'exécution du programme.
Dans le cas de la figure 1 , une instruction à préserver est identifiée dans la zone pouvant être accédée par une instruction de saut et en amont de cette instruction de saut.
En cas d'attaque sur l'instruction de saut, cette instruction peut atteindre de manière équiprobable l'ensemble des instructions appartenant à la zone mémoire allant de -(2n"1 -1 ) à 2n"1 -1.
Cependant, afin de limiter la probabilité d'atteindre l'instruction à préserver, il est inséré des instructions non opérant entre l'instruction à préserver et l'instruction de saut. Cette insertion a pour rôle de faire sortir l'instruction à préserver de la zone mémoire accessible par l'instruction de saut, tout en sachant que l'exécution du programme s'effectue par adresse croissante.
Ainsi, préférentiellement, l'instruction à préserver ne doit pas être positionnée à une adresse supérieure que son adresse initiale lors de l'insertion d'un lot opérant. En effet, lors d'une attaque sur l'adresse de saut, si le saut aboutit à une adresse inférieure ou à une adresse équivalente à l'instruction à préserver, et si l'instruction à préserver est positionnée à une adresse supérieure alors cette instruction à préserver sera exécutée.
Ces instructions non opérant formant un lot non opérant sont, par exemple des instructions dont les faits se neutralisent, c'est-à-dire par exemple, des instructions d'incrément et de décrément d'une variable, ou des instructions d'affectation d'une variable non utilisée dans le reste du programme.
Le lot non opérant, étant une suite d'instructions ayant aucun effet sur le programme, est inséré dans le programme de manière à ce que l'instruction de contournement empêche normalement l'exécution des instructions de ce lot et qu'une instruction d'éjection située à la fin de ce lot empêche l'exécution d'instructions en aval de ce lot. En référence à la figure 1 , le lot non opérant est inséré entre l'instruction à préserver et l'instruction de saut. Ce lot peut comporter en premier lieu, sensiblement dans les premières instructions, une instruction de contoumement permettant d'atteindre l'instruction suivant le lot non opérant. Si une instruction de contoumement est située avant ce lot non opérant, alors le lot comporte de manière optionnelle cette instruction de contoumement.
Cependant, l'insertion d'une telle instruction évite lors d'une exécution normale du programme, l'exécution de ce lot non opérant, n'introduisant ainsi aucune pénalité de temps d'exécution de ce programme.
De même, ce lot peut comprendre sensiblement à la fin, une instruction d'éjection vers un programme d'action, cette instruction empêchant l'exécution d'instructions en aval de ce lot.
L'instruction d'éjection est une instruction non opérant de type instruction de saut, ou instruction d'appel de sous programme qui a comme argument, l'adresse du programme d'action.
Ainsi, en cas d'attaque, lorsque l'instruction de saut aboutit au sein de ce lot non opérant, l'exécution de ce programme est déroutée vers un programme d'action. Ce programme d'action est composé d'au moins une instruction visant à exécuter une contre-mesure ou plus généralement, un lot sécuritaire. Par exemple, il peut s'agir d'un programme de destruction de la carte, l'exécution d'une boucle infinie ou la réinitialisation du programme. Ii peut s'agir également d'un lot sécuritaire, c'est-à-dire un ensemble d'instructions réalisant une action sensible dont la non exécution peut mettre en péril la sécurisation du système. Par exemple, le lot sécuritaire peut être destiné à lire une clé sensible ou à réaliser une authentification avant d'autoriser un accès.
En référence à la figure 2, il est décrit un cas particulier où l'instruction à préserver précède l'adresse visée par l'instruction de saut. Dans un tel cas, afin de protéger au mieux l'instruction à préserver, un lot non opérant doit être inséré entre l'instruction à préserver et l'adresse visée par le saut. Ainsi l'instruction à préserver est éloignée de l'instruction de saut et est préférablement sortie de la zone accessible par l'instruction de saut.
Préférentiellement, ce lot non opérant comporte un nombre d'instructions tel que, après son insertion, l'instruction à préserver est sortie de la zone mémoire accessible par l'instruction de saut.
Afin de faire sortir l'instruction à préserver de la zone mémoire accessible par l'instruction du saut, ce nombre d'instructions doit être au minimum de m = 2n"1 + x, où n est le nombre d'éléments binaires sur lesquels l'adresse relative visée par l'instruction de saut est codée, et x l'adresse relative de l'instruction à préserver par rapport à l'instruction de saut.
En référence à la figure 3, il est décrit un autre cas particulier dans lequel l'adresse visée par l'instruction de saut précède l'instruction à préserver identifiée.
Dans un tel cas de figure, il est avantageusement inséré le lot d'instructions non opérant entre l'instruction à préserver et l'instruction de saut.
En effet, de même que pour les exemples de la figure 1 et de la figure 3, l'instruction à préserver est préférentiellement éloignée de l'instruction de saut.
Cependant étant donné que l'adresse visée par l'instruction de saut a une adresse inférieure à celle de l'instruction à préserver, cette instruction à préserver ne peut pas être sortie de la zone mémoire accessible par l'instruction de saut.
Ainsi le nombre d'instructions que peut contenir le lot d'instructions non opérant inséré est au maximum de p instructions avec p = 2n"1 - 1 + y, où n est le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, et y l'adresse relative visée par l'instruction de saut.
L'insertion d'un tel lot permet de remonter l'instruction à préserver de telle sorte que, au maximum, l'adresse visée par l'instruction de saut est la première adresse accessible dans la zone mémoire.
En référence à la figure 4, il est représenté un cas particulier où l'instruction de saut précède l'instruction à préserver.
Avantageusement, le lot non opérant est inséré entre l'instruction de saut et l'instruction à préserver. Lorsque ce lot non opérant est exécuté suite à une attaque, ce lot comprend sensiblement à la fin de ce lot d'instructions, une instruction d'éjection empêchant l'exécution d'instructions en aval de ce lot.
Dans le cas où l'adresse visée par l'instruction de saut est en aval de l'instruction à préserver, le lot non opérant est inséré entre l'instruction de saut et l'instruction à préserver repoussant ainsi l'instruction à préserver de l'instruction de saut, tel que montré à la figure 5.
Si l'adresse visée par l'instruction de saut est en amont de l'instruction à préserver, alors le lot non opérant est préférentiellement inséré en aval de l'adresse visée par l'instruction de saut.
Cette insertion a pour rôle de faire sortir l'instruction à préserver de la zone mémoire accessible par l'instruction de saut.
Afin de faire sortir l'instruction à préserver de la zone mémoire accessible par l'instruction de saut, ce lot non opérant doit comprendre au minimum r instructions avec r = 2π'1 - y, où n est le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, et y l'adresse relative de l'instruction à préserver.
En référence à la figure 7, l'insertion d'un lot non opérant peut être effectuée juste avant l'adresse visée par l'instruction de saut lorsque l'adresse visée par l'instruction de saut est en amont de l'instruction à préserver.
En référence à la figure 8, l'insertion d'un lot non opérant peut-être effectuée après l'instruction à préserver lorsque celle-ci se trouve en aval de l'instruction de saut. Ce lot comprend préférentiellement, une instruction de contournement, sensiblement dans les premières instructions de ce lot, et une instruction d'éjection à la fin du lot qui empêche l'exécution d'instructions en aval de ce lot.
De manière complémentaire à la préservation d'instructions sensibles, des lots non opérants peuvent servir à favoriser un lot sécuritaire, par exemple les instructions constituant, après un saut, l'alternative aux instructions à préserver.
Ainsi, le procédé peut par l'insertion de lot non opérant, favoriser l'exécution d'un lot d'instructions sécuritaires, ce dernier étant formé d'un ensemble d'instructions qui doivent être exécutées pour la sécurité du programme.
Les instructions du lot sécuritaire sont des instructions réalisant des actions sensibles dont leur non exécution suite à une attaque, alors que cette instruction aurait été normalement exécutée, peut mettre en péril la sécurité du système.
Une exécution répétée d'un lot sécuritaire non prévue par le programme ne met généralement pas en péril la sécurité du système.
Par exemple, un lot sécuritaire peut consister à accéder à une clé en mémoire, par exemple de type EEPROM, avant d'exécuter un cryptage de données sensibles, le résultat du cryptage devant être envoyées par la carte au terminal. Si la clé de cryptage n'est pas lue suite à une attaque, la carte risque de renvoyer la donnée sensible au terminal, en clair ou crypté avec une clé dégénérée, ce qui peut mettre en péril la sécurité de ces données. Ceci est particulièrement important lors de la manipulation de données secrètes.
Ainsi, l'exécution d'un tel lot sécuritaire, malgré une faute fonctionnelle ou suite à une attaque, doit être exécuté afin d'assurer par exemple, que la lecture de la clé est bien effectuée.
Selon un second exemple de lot sécuritaire, le calcul et la vérification d'une valeur de checksum, par exemple, accompagnant chaque enregistrement mémorisé dans la mémoire d'une carte à puce, doivent être exécutés après la lecture de données dans un fichier, notamment suite à une commande de lecture (instruction « read »), et avant que la carte émette les données lues vers le terminal dans lequel est insérée la carte à puce. Ainsi la carte vérifie qu'elle a bien lu les données et que les données qu'elle mémorise sont intègres.
Une attaque peut consister, par exemple à perturber la lecture de façon à effectuer cette lecture dans des zones non autorisées, zone pouvant comporter un secret. La vérification de la valeur de checksum effectuée par la carte pose problème pour un attaquant, puisque la lecture perturbée conduit dans la plupart des cas à ce que la carte lise la valeur de checksum dans une zone de Ia mémoire où il y a des données autres et non cette valeur de checksum. Ainsi cette valeur de checksum issue de données lues dans la mémoire par la carte et la valeur de checksum calculée par la carte ne se correspondent pas. Cette carte détecte alors une erreur de lecture et ne renvoie pas la donnée lue au terminal.
Le lot sécuritaire peut ainsi être un traitement d'anomalie, issue par exemple d'une erreur fonctionnelle ou de la détection d'une attaque. Ainsi, un lot non opérant est inséré de telle sorte que lors d'une faute, on augmente la probabilité que le saut atteigne ce lot non opérant, ce lot non opérant conduisant à l'exécution du lot sécuritaire.
La figure 9 illustre un programme en assembleur où est représenté deux instructions à préserver en amont de l'instruction de saut. Ces instructions sont à préserver car elles peuvent être dangereuses si elles sont exécutées à un moment imprévu par le programme, suite par exemple à une attaque par faute. Ces deux instructions sont d'une part l'instruction « call appeU » qui est un appel à un sous programme « appeli » et d'autre part, l'instruction « inc a » qui est une instruction d'incrémentation d'une variable. L'instruction de saut « jz etiq » (signifiant « saut si le résultat de l'instruction précédente est égal à 0 ») est en aval de ces deux instructions à préserver. La figure 10, obtenue à partir de l'exemple de la figure 9, montre l'insertion d'instructions non opérantes dans la zone mémoire accessible par l'instruction de saut conditionnel « jz etiq », permettant de repousser des instructions à préserver à l'extérieur de cette zone mémoire tel que montré à la figure 1 et à la figure 2. Ainsi on limite le risque qu'un attaquant atteigne une instruction à préserver suite à une attaque par faute réalisée sur cette instruction de saut. La sécurité de l'exécution de ce programme est ainsi améliorée.
Le lot non opérant inséré entre l'instruction à préserver et l'instruction de saut, peut ne pas contenir d'instruction d'éjection. En effet si un attaquant atteint une instruction de ce lot alors l'exécution du programme repassera par l'instruction de saut et donc par le test précédant cette instruction, instruction « and », ce qui assure que cette instruction de saut sera ré-exécutée assurant ainsi la sécurisation du programme.
En référence à la figure 9, une instruction à préserver est située en aval de l'instruction de saut, cette instruction est l'instruction « call appel4 ». La figure 10 montre qu'afin de préserver cette instruction, un lot non opérant est inséré entre l'instruction de saut et l'instruction à préserver, également montré à la figure 4. Cependant, dans le cas de cette figure 4, si un attaquant atteint une instruction du lot non opérant située entre l'instruction de saut et l'instruction à préserver, en l'absence d'instructions d'éjection de type saut ou appel d'un sous programme, l'instruction à préserver est tout de même exécutée. Tel que décrit précédemment en référence à la figure 4, ce lot non opérant doit, préférentiellement, comporter une instruction d'éjection empêchant l'exécution des instructions en aval de ce lot.
La figure 11 présente un autre exemple de programme en assembleur, où il est présenté le cas d'une instruction de saut inconditionnel « jump », précédant les instructions à préserver suivantes : « call appeU » et « inc a ».
La figure 12 obtenue à partir de la figure 11 illustre la sécurisation du programme assembleur de la figure 11. Concernant les instructions à préserver suivantes « call appel 1 » et « inc a », elles sont situées en aval de l'adresse visée par l'instruction de saut « etiq 2 ». Afin de sécuriser ces instructions tel que présenté à la figure 6, il est inséré des lots non opérant entre l'adresse visée par l'instruction de saut et les instructions à préserver, provoquant la sortie de ces instructions de la zone accessible par l'instruction de saut. Ces instructions sont maintenant non directement accessibles par l'instruction de saut.
On peut noter que l'exemple de la figure 11 , comporte des instructions éventuellement sensibles, par exemple l'instruction « call appel2 », qui ne sont pas protégées par des lots non opérants. On peut, au choix, décider d'itérer (ou non) la démarche de sécurisation à propos de ces autres instructions à préserver.Selon un mode de réalisation, après sécurisation de la zone mémoire par insertion de lots non opérants, celle-ci comporte au moins 90 % d'instructions non opérant. Ainsi il est maximiser la probabilité pour qu'un attaquant perturbant l'adresse de l'instruction de saut atteigne une instruction d'un lot non opérant. Ainsi, le risque d'atteindre une instruction à préserver est limité. En référence à la figure 13, un attaquant peut tenter de perturber l'instruction de saut afin d'empêcher l'exécution d'un programme de traitement d'anomalie. Ainsi selon l'exemple de la figure 13, l'attaquant peut, par exemple, exécuter le code consistant à lire des données en mémoire et récupérer ces données frauduleusement. Par exemple, l'attaquant peut sauter l'instruction « CaII traitement_anomalie », appel qui a lieu lorsque le calcul et la vérification du checksum sont invalides, ces opérations devant avoir lieu avant que les données lies soient émises au terminal dans lequel est inséré la carte à puce en vue de vérifier leur intégrité.
Afin de s'assurer qu'un lot sécuritaire est exécuté en cas d'attaque, au moins un lot non opérant est placé aux adresses précédant immédiatement le lot sécuritaire, comme illustré à la figure 14. Le lot sécuritaire identifié est l'appel au programme d'action « call traitement_anomalie ». Ainsi si l'attaquant tombe sur une instruction non opérante appartenant au lot non opérant lors par exemple, d'une attaque, il est tout de même effectué le lot sécuritaire. En effet, les instructions non opérantes du lot non opérant conduisent l'exécution du programme vers le lot sécuritaire, forçant ainsi son exécution. . Ainsi, selon l'invention, la probabilité d'exécuter un lot sécuritaire est augmentée alors que la probabilité d'exécuter une instruction à préserver est diminuée. Les figures 15 et 16 illustrent deux exemples de sécurisation de programme dans le cas d'un saut conditionnel. Selon ces exemples, on appelle « instructions alternatives », les instructions constituant une alternative à l'exécution des instructions situées à l'adresse visée par l'instruction de saut conditionnel. Selon un premier mode de réalisation, les instructions alternatives comprennent en outre, l'instruction à préserver « call suite_prog », ayant pour rôle la poursuite normale du programme. Cette instruction est située après l'instruction de saut et est accessible par l'instruction de saut. Par exemple, cette instruction est la première instruction après cette instruction de saut. Selon l'exemple de la figure 15, les instructions alternatives contiennent l'instruction à préserver suivie d'un lot non opérant s'étendant jusqu'au bout de la zone mémoire, par exemple, en tant que cas particulier de la figure 8.
Le lot sécuritaire contenant le traitement d'anomalie est située sensiblement dans les dernières adresses de la zone mémoire accessible par l'instruction de saut. Selon un mode de réalisation particulier, le lot non opérant est inséré de tel sorte que le lot sécuritaire débute à la dernière instruction accessible de cette zone mémoire. On obtient ainsi, une protection optimale pour la zone mémoire immédiatement suivant l'instruction de saut.
En effet, il est minimisé la probabilité d'exécuter l'instruction à préserver, et maximisé la probabilité d'exécuter le lot sécuritaire, le lot non opérant, formé d'instructions non opérantes conduisant l'exécution du programme, en cas d'attaque, au lot sécuritaire.
Cette mise en œuvre peut également être réalisée dans la zone mémoire située avant l'instruction de saut. Dans ce cas, le lot sécuritaire est juste avant l'instruction de saut et l'éventuelle instruction de test qui conditionne le saut, et l'insertion du lot non opérant est telle que l'instruction à préserver est au début de la zone mémoire.
Selon un second mode de réalisation illustré à la figure 16, les instructions alternatives comprennent le lot sécuritaire. Selon cette figure, le lot sécuritaire précède l'instruction à préserver. Afin de maximiser la probabilité d'exécuter le lot sécuritaire et minimiser l'exécution de l'instruction à préserver en cas d'attaque, un lot d'instructions non opérant est inséré après l'instruction de saut et en amont du lot sécuritaire. Par exemple, le lot non opérant est placé immédiatement après l'instruction de saut. Ainsi, ce lot non opérant est suivi tout d'abord, de l'instruction alternative (le lot sécuritaire) et ensuite de l'instruction à préserver, celle-ci devant rester accessible par l'adresse visée par l'instruction de saut, l'instruction de saut ayant pour objectif d'atteindre cette instruction à préserver. Ainsi, on obtient également une protection optimale pour la zone mémoire suivant l'instruction de saut, puisque la probabilité d'exécuter l'instruction à préserver est minimisée et la probabilité d'exécuter le lot sécuritaire est maximisée, suite, par exemple, à une attaque par faute. Cette mise en œuvre peut également être réalisée dans la zone mémoire située avant l'instruction de saut.
Selon une variante de l'invention, l'instruction de saut est telle qu'elle permet uniquement de réaliser un saut vers l'avant. De cette façon on obtient une protection optimale grâce à l'invention telle qu'illustrée dans les figures 15 et 16. En effet il n'y a pas de risque qu'en cas d'attaque le saut atteigne une instruction précédant l'instruction de saut.
Selon une autre variante, une nouvelle instruction de saut conditionnel peut être envisagée, cette instruction ayant en paramètres, deux adresses relatives de saut. Les instructions conditionnelles connues telles que « jz » ou « jnz », ont un paramètre indiquant une adresse relative de saut. Ces instructions ont deux sorties fonctionnelles. En effet, ces instructions réalisent un saut à l'adresse relative si le résultat de l'instruction précédente est respectivement égal à 0 ou non égal à 0, sinon l'exécution se poursuit à l'adresse suivant l'instruction de saut. Selon l'invention, la nouvelle instruction de saut comporte deux adresses relatives, de tel sorte que cette instruction réalise un saut à la première adresse relative si le résultat de l'instruction précédente est par exemple, égal à 0, ou un saut à la seconde adresse relative dans le cas contraire. Un programme comprenant cette nouvelle instruction peut être sécurisé par l'ajout de lots d'instructions non opérants et de lots d'instructions sécuritaires, par exemple, avant la première adresse de saut, avant la deuxième adresse de saut.

Claims

REVENDICATIONS
1. Procédé de sécurisation d'un programme contre des attaques par faute, notamment dans une carte à puce, selon lequel
- on identifie dans ce programme au moins une instruction de saut comportant une adresse relative choisie parmi une pluralité d'adresses relatives possibles, et permettant d'atteindre une adresse visée au sein d'une zone mémoire s'étendant avant et après cette instruction de saut et regroupant cette pluralité d'adresses relatives possibles,
- au sein de cette zone mémoire, on identifie une instruction à préserver et,
- pour sécuriser au moins cette instruction, on insère au moins un premier lot non opérant comportant au moins une instruction, cette insertion étant réalisée de telle sorte que : - cette insertion est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire,
- cette insertion est compatible avec le déroulement normal du programme.
2. Procédé de sécurisation selon la revendication 1 , caractérisé en ce que le procédé comprend les étapes suivantes :
- identification dans le programme d'un lot sécuritaire comportant au moins une instruction à exécuter,
- insertion d'un lot non opérant, distinct ou non du premier lot non opérant, précédant le lot sécuritaire identifié et propre à en favoriser l'exécution.
3. Procédé de sécurisation selon la revendication 1 , caractérisé en ce que le premier lot non opérant est inséré dans le programme de manière à ce qu'une instruction de contoumement empêche normalement l'exécution des instructions du lot et qu'une instruction d'éjection vers un programme d'action, à la fin du lot empêche l'exécution d'instructions en aval de ce lot.
4. Procédé de sécurisation selon la revendication 3, caractérisé en ce que le programme d'action comprend un lot sécuritaire comportant au moins une instruction à exécuter.
5. Procédé de sécurisation selon la revendication 3 ou 4, caractérisé en ce que l'instruction de contoumement fait partie du programme à sécuriser et précède le lot non opérant de telle sorte que ce lot non opérant n'est normalement pas exécuté.
6. Procédé de sécurisation selon la revendication 3 ou 4, caractérisé en ce que l'instruction de contoumement est au début du lot non opérant et renvoie vers la première instruction du programme en aval de ce lot non opérant.
7. Procédé de sécurisation selon la revendication 1 , caractérisé en ce que l'insertion du lot non opérant est effectuée après la première des dites instructions de saut ou à préserver.
8. Procédé de sécurisation selon la revendication 7, caractérisé en ce que l'insertion du lot non opérant est effectuée entre l'instruction à préserver et l'instruction de saut si cette instruction à préserver précède l'instruction de saut.
9. Procédé de sécurisation selon la revendication 8, caractérisé en ce que lorsque l'instruction à préserver précède l'adresse visée par l'instruction de saut, le lot non opérant comporte un nombre d'instructions tel que, après insertion, l'instruction à préserver est en amont de la zone mémoire accessible par l'instruction de saut.
10. Procédé de sécurisation selon la revendication 9, caractérisé en ce que le lot non opérant comprend au minimum m instructions avec m = 2n~1 + ADR_A_PRESERVER, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, et ADR_A_PRESERVER l'adresse relative de l'instruction à préserver par rapport à l'instruction de saut.
11. Procédé de sécurisation selon la revendication 8, caractérisé en ce que lorsque l'adresse visée par l'instruction de saut précède l'instruction à préserver, le lot non opérant comprend au maximum p instructions avec p = 2n"1 -1 + ADR_SAUT, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, et ADR_SAUT l'adresse relative visée par l'instruction de saut, grâce à quoi l'instruction cible reste dans la zone mémoire après sécurisation.
12. Procédé de sécurisation selon l'une quelconque des revendications 8 à 11, caractérisé en ce que le lot non opérant est inséré de manière à n'être exécuté qu'en cas de perturbation de l'instruction de saut, une instruction de contournement empêchant normalement l'exécution d'instructions de ce lot non opérant.
13. Procédé de sécurisation selon la revendication 12, caractérisé en ce que ce lot non opérant comporte à la fin du lot non opérant, une instruction d'éjection empêchant l'exécution d'instructions en aval de ce lot non opérant.
14. Procédé de sécurisation selon la revendication 7, caractérisé en ce que le lot non opérant est inséré entre l'instruction de saut et l'instruction à préserver de manière à n'être exécuté qu'en cas de perturbation de l'instruction de saut, une instruction d'éjection à la fin du lot non opérant empêche l'exécution d'instructions en aval de ce lot non opérant.
15. Procédé de sécurisation selon la revendication 14, caractérisé en ce que le lot non opérant est inséré juste en amont de l'adresse visée par l'instruction de saut lorsque l'adresse visée par l'instruction de saut est en amont de l'instruction à préserver.
16. Procédé de sécurisation selon la revendication 14, caractérisé en ce qu'une instruction de contoumement empêche normalement l'exécution d'instructions du lot non opérant.
17. Procédé de sécurisation selon la revendication 16, caractérisé en ce que l'instruction de contoumement est au début du lot non opérant, et renvoie vers la première instruction du programme en aval de ce lot non opérant.
18. Procédé de sécurisation selon la revendication 14, caractérisé en ce que lorsque l'instruction à préserver précède l'adresse visée par l'instruction de saut, le lot non opérant comprend au maximum q instructions avec q = 2n~1 - 1 - ADR_SAUT, n étant le nombre d'éléments binaires sur lesquels l'adresse relative visée par l'instruction de saut est codée, et ADR_SAUT l'adresse relative visée par l'instruction de saut, grâce à quoi l'instruction cible reste dans la zone mémoire après sécurisation.
19. Procédé de sécurisation selon la revendication 14, caractérisé en ce que lorsque l'adresse visée par l'instruction de saut précède l'instruction à préserver, le lot non opérant est inséré entre l'adresse visée par l'instruction de saut et l'instruction à préserver.
20. Procédé de sécurisation selon la revendication 19, caractérisé en ce que l'instruction à préserver est à la fin de la zone mémoire après l'instruction de saut.
21. Procédé de sécurisation selon la revendication 19, caractérisé en ce que le lot non opérant comporte un nombre d'instructions tel que, après insertion, l'instruction à préserver est en aval de la zone mémoire.
22. Procédé de sécurisation selon la revendication 21 , caractérisé en ce que le lot non opérant comprend au minimum r instructions avec r = 2n"1 - ADR_A_PRESERVER, n étant le nombre d'éléments binaires sur lesquels l'adresse relative du saut est codée, et ADR_A_PRESERVER l'adresse relative de l'instruction à préserver par rapport à l'instruction de saut.
23. Procédé de sécurisation selon la revendication 7, caractérisé en ce que l'insertion est effectuée après la seconde des dites instructions du programme de manière à ce qu'une instruction de contoumement empêche normalement l'exécution des instructions du lot non opérant et qu'une instruction d'éjection à la fin du lot non opérant empêche l'exécution d'instructions en aval de ce lot.
24. Procédé de sécurisation selon la revendication 23, caractérisé en ce que l'instruction de contoumement fait partie du programme à sécuriser et précède le lot non opérant de telle sorte que ce lot non opérant n'est normalement pas exécuté.
25. Procédé de sécurisation selon la revendication 23, caractérisé en ce que l'instruction de contoumement est au début du lot non opérant renvoyant vers la première instruction du programme en aval de ce lot non opérant.
26. Procédé de sécurisation selon la revendication 2, caractérisé en ce que l'instruction à préserver précédant le lot sécuritaire, l'instruction à préserver et le lot sécuritaire étant du même côté par rapport à l'instruction de saut, l'insertion du lot non opérant est effectuée entre l'instruction à préserver et le lot sécuritaire.
27. Procédé selon la revendication 26, caractérisé en ce que l'instruction à préserver étant juste après l'instruction de saut, l'insertion du lot non opérant est telle que le lot sécuritaire est à la fin de la zone mémoire.
28. Procédé selon la revendication 26, caractérisé en ce que le lot sécuritaire étant juste avant l'instruction de saut, l'insertion du lot non opérant est telle que l'instruction à préserver est au début de la zone mémoire.
29. Procédé de sécurisation selon la revendication 2, caractérisé en ce que le lot sécuritaire précédant l'instruction à préserver, le lot sécuritaire et l'instruction à préserver étant du même côté par rapport à l'instruction de saut, l'insertion du lot non opérant est en amont du lot sécuritaire et est effectuée du même côté que le lot sécuritaire par rapport à l'instruction de saut.
30. Procédé selon la revendication 29, caractérisé en ce que l'insertion du lot non opérant est telle que l'instruction à préserver est à la fin de la zone mémoire.
31. Procédé de sécurisation selon l'une quelconque des revendications 1 à 30, caractérisé en ce que, après insertion dudit lot non opérant, on identifie au sein de cette zone mémoire au moins une autre instruction à préserver et, pour sécuriser cette autre instruction, on insère un autre lot non opérant comportant au moins une instruction, cette instruction étant exécutée en respectant les dites conditions.
32. Procédé de sécurisation selon l'une quelconque des revendications 1 à 30, caractérisé en ce que, avant insertion dudit lot non opérant, on identifie au sein de cette zone mémoire au moins une autre instruction à préserver, et on insère ledit lot non opérant de sorte à respecter les conditions vis-à-vis de chacune des instructions à préserver.
33. Procédé de sécurisation selon l'une quelconque des revendications précédentes, caractérisé en ce que, après sécurisation de la zone mémoire s'étendant avant et après cette instruction de saut, la zone mémoire comporte au moins 90 % d'instructions faisant parties de lots non opérant insérés.
34. Procédé de sécurisation selon l'une quelconque des revendications précédentes, caractérisé en ce qu'un lot non opérant comprend une pluralité d'instructions.
35. Procédé de sécurisation selon l'une quelconque des revendications précédentes, caractérisé en ce que le lot non opérant comprend au moins une instruction d'éjection vers un programme d'action.
36. Procédé de sécurisation selon l'une quelconque des revendications précédentes, caractérisé en ce que le lot non opérant inséré comprend au moins une instruction d'éjection vers un sous programme d'action.
37. Procédé de sécurisation selon la revendication 35 ou 36, caractérisé en ce que le programme d'action comprend un lot sécuritaire comportant au moins une instruction à exécuter.
38. Procédé de sécurisation selon la revendication 35 ou 36, caractérisé en ce que le programme d'action comprend des instructions de fin prématurée d'exécution du programme.
39. Procédé de sécurisation selon la revendication 35 ou 36, caractérisé en ce que le programme d'action comprend des instructions de réinitialisation de l'exécution du programme.
40. Procédé d'exécution sécurisé d'un programme contre des attaques par faute, notamment dans une carte à puce, caractérisé en ce que, préalablement à l'exécution dudit programme, on met en œuvre une étape de sécurisation du programme conforme à l'une quelconque des revendications 1 à 39.
41. Dispositif de sécurisation d'un programme contre des attaques par faute, notamment dans une carte à puce, selon lequel le dispositif comprend :
- un moyen pour identifier dans ce programme au moins une instruction de saut comportant une adresse relative choisie parmi une pluralité d'adresses relatives possibles, et permettant d'atteindre une adresse visée au sein d'une zone mémoire s'étendant avant et après cette instruction de saut et regroupant cette pluralité d'adresses relatives possibles,
- un moyen pour identifier une instruction à préserver au sein de la zone mémoire et, - un moyen pour insérer au moins un premier lot non opérant comportant au moins une instruction pour sécuriser au moins cette instruction, cette insertion étant réalisée de telle sorte que :
- cette insertion est compatible avec le maintien de l'adresse visée par l'instruction de saut à l'intérieur de la zone mémoire, - cette insertion est compatible avec le déroulement normal du programme.
42. Dispositif de sécurisation selon la revendication 41 , caractérisé en ce que le moyen pour insérer au moins un premier lot non opérant effectue cette insertion après la première des dites instructions.
43. Dispositif selon la revendication 41 ou 42, caractérisé en ce qu'il comporte :
- un moyen d'identification dans le programme d'un lot sécuritaire comportant au moins une instruction à exécuter ; - un moyen d'insertion d'un lot non opérant, distinct ou non du premier lot non opérant, précédant le lot sécuritaire identifié et propre à en favoriser l'exécution.
44. Circuit électronique intégré caractérisé en ce qu'il est adapté à mettre en œuvre un procédé d'exécution conforme à la revendication 40.
45. Carte à microcircuit caractérisée en ce qu'elle comporte circuit électronique intégré conforme à la revendication 41.
46. Système informatique caractérisé en ce qu'il comporte un circuit électronique intégré conforme à la revendication 41.
47. Support d'informations lisible par un système informatique, éventuellement totalement ou partiellement amovible, notamment CD-ROM ou support magnétique, tel un disque dur ou une disquette, ou support transmissible tel un signal électrique ou optique, caractérisé en ce qu'il comporte des instructions d'un programme informatique permettant la mise ne œuvre d'un procédé de sécurisation selon l'une quelconque des revendications 1 à 39, lorsque ce programme est chargé et exécuté par un système informatique.
48. Programme d'ordinateur stocké sur un support d'informations, ledit programme comportant des instructions permettant la mise en œuvre d'un procédé de sécurisation selon l'une quelconque des revendications 1 à 39, lorsque ce programme est chargé et exécuté par un système informatique.
49. Carte à microcircuit caractérisée en ce qu'elle comporte des moyens de mise en œuvre d'un procédé de sécurisation selon l'une quelconque des revendications 1 à 39.
PCT/FR2005/002582 2004-10-22 2005-10-18 Protection contre les attaques par generation de fautes sur les instructions de saut WO2006045924A1 (fr)

Priority Applications (1)

Application Number Priority Date Filing Date Title
US11/665,991 US8266423B2 (en) 2004-10-22 2005-10-18 Protection against attacks by generation of errors on jump instructions

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR0411317A FR2877118B1 (fr) 2004-10-22 2004-10-22 Protection contre les attaques par generation de fautes sur les instructions de saut
FR0411317 2004-10-22

Publications (1)

Publication Number Publication Date
WO2006045924A1 true WO2006045924A1 (fr) 2006-05-04

Family

ID=34954064

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2005/002582 WO2006045924A1 (fr) 2004-10-22 2005-10-18 Protection contre les attaques par generation de fautes sur les instructions de saut

Country Status (3)

Country Link
US (1) US8266423B2 (fr)
FR (1) FR2877118B1 (fr)
WO (1) WO2006045924A1 (fr)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20090254782A1 (en) * 2006-12-18 2009-10-08 Stmicroelectronics Sa Method and device for detecting an erroneous jump during program execution

Families Citing this family (18)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7577992B2 (en) * 2005-01-14 2009-08-18 Microsoft Corporation Software security based on control flow integrity
FR2925968B1 (fr) * 2007-12-26 2011-06-03 Ingenico Sa Procede de securisation d'un microprocesseur, programme d'ordinateur et dispositif correspondants
WO2009144606A1 (fr) * 2008-05-30 2009-12-03 Nxp B.V. Procédé permettant d'adapter et d'exécuter un programme informatique et architecture informatique correspondante
CN102713839B (zh) * 2009-10-08 2015-11-25 爱迪德技术有限公司 用于动态函数调用***中的积极自我修改的***和方法
JP5588781B2 (ja) * 2010-08-10 2014-09-10 富士通株式会社 セキュアモジュールおよび情報処理装置
FR2967275B1 (fr) * 2010-11-10 2012-12-28 Oberthur Technologies Procede, programme d'ordinateur et dispositif de securisation de code intermediaire de programmation pour son execution par une machine virtuelle
WO2012145917A1 (fr) * 2011-04-29 2012-11-01 北京中天安泰信息科技有限公司 Procédé et dispositif de recombinaison d'instruction d'exécution
US8839429B2 (en) * 2011-11-07 2014-09-16 Qualcomm Incorporated Methods, devices, and systems for detecting return-oriented programming exploits
US10331891B2 (en) * 2012-02-06 2019-06-25 Microsoft Technology Licensing, Llc Branch target computation in secure start-up using an integrity datum and an adjustment datum
KR101977772B1 (ko) 2012-07-12 2019-05-13 삼성전자주식회사 데이터 처리 장치 및 이를 포함하는 보안 메모리 장치
CN103679042B (zh) * 2012-09-06 2016-09-14 中天安泰（北京）信息技术有限公司 数据安全存储方法及装置
US9727729B2 (en) * 2014-06-24 2017-08-08 Virsec Systems, Inc. Automated code lockdown to reduce attack surface for software
CN105809011B (zh) * 2014-12-31 2019-02-05 北京华大智宝电子***有限公司 一种可以动态加载应用的二代USB Key兼容Java Card平台的方法
FR3072477B1 (fr) * 2017-10-13 2019-11-15 Idemia France Securisation d’instructions de branchement conditionnel compose dans un programme informatique en code intermediaire
US20230099751A1 (en) * 2020-03-17 2023-03-30 Nec Corporation Processing apparatus, security control method, and non-transitory computerreadable medium
CN111552959B (zh) * 2020-06-18 2023-08-29 南方电网科学研究院有限责任公司 一种程序特征序列生成方法和装置
FR3116356B1 (fr) 2020-11-13 2024-01-05 Stmicroelectronics Grand Ouest Sas Procédé de compilation d’un code source
CN117015765A (zh) * 2021-02-10 2023-11-07 微芯片技术股份有限公司 计算机可读指令的陷阱子部分以及相关***、方法和装置

Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6108797A (en) * 1997-12-11 2000-08-22 Winbond Electronics Corp. Method and system for loading microprograms in partially defective memory

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5408642A (en) * 1991-05-24 1995-04-18 Symantec Corporation Method for recovery of a computer program infected by a computer virus
US6272637B1 (en) * 1997-04-14 2001-08-07 Dallas Semiconductor Corporation Systems and methods for protecting access to encrypted information
FR2832824A1 (fr) * 2001-11-28 2003-05-30 St Microelectronics Sa Blocage du fonctionnement d'un circuit integre
US7752459B2 (en) * 2001-12-06 2010-07-06 Novell, Inc. Pointguard: method and system for protecting programs against pointer corruption attacks
EP1596283B1 (fr) * 2004-05-11 2009-07-01 St Microelectronics S.A. Protection d'un branchement dans un programme

Patent Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6108797A (en) * 1997-12-11 2000-08-22 Winbond Electronics Corp. Method and system for loading microprograms in partially defective memory

Non-Patent Citations (5)

* Cited by examiner, † Cited by third party
Title
A. MONDEN ET AL: "Obfuscated Instructions for Software Protection", November 2003 (2003-11-01), XP002329913, ISSN: 0919-9527, Retrieved from the Internet <URL:http://www.cs.auckland.ac.nz/~cthombor/Pubs/2003013.pdf> [retrieved on 20050530] *
COHEN F B: "OPERATING SYSTEM PROTECTION THROUGH PROGRAM EVOLUTION", COMPUTERS & SECURITY, ELSEVIER SCIENCE PUBLISHERS. AMSTERDAM, NL, vol. 12, no. 6, 1 October 1993 (1993-10-01), pages 565 - 584, XP000415701, ISSN: 0167-4048 *
HAGAI BAR-EL ET AL: "The Sorcerer's Apprentice Guide to Fault Attacks", 7 May 2004 (2004-05-07), XP002329915, Retrieved from the Internet <URL:http://web.archive.org/web/20041016071838/eprint.iacr.org/2004/100> [retrieved on 20050527] *
KANZAKI Y ET AL: "Exploiting self-modification mechanism for program protection", 3 November 2003, PROCEEDINGS OF THE 27TH. ANNUAL INTERNATIONAL COMPUTER SOFTWARE AND APPLICATIONS CONFERENCE. COMPSAC 2003. DALLAS, TX, NOV. 3 - 6, 2003, ANNUAL INTERNATIONAL COMPUTER SOFTWARE AND APPLICATIONS CONFERENCE, LOS ALAMITOS, CA, IEEE COMP. SOC, US, PAGE(S), ISBN: 0-7695-2020-0, XP010669091 *
PROF. JEAN-JACQUES QUISQUATER: "Side channel attacks - State-of-the-art", October 2002 (2002-10-01), XP002329914, Retrieved from the Internet <URL:http://www.ipa.go.jp/security/enc/CRYPTREC/fy15/doc/1047_Side_Channel_report.pdf> [retrieved on 20050527] *

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20090254782A1 (en) * 2006-12-18 2009-10-08 Stmicroelectronics Sa Method and device for detecting an erroneous jump during program execution
US8495734B2 (en) * 2006-12-18 2013-07-23 Stmicroelectronics Sa Method and device for detecting an erroneous jump during program execution

Also Published As

Publication number Publication date
FR2877118A1 (fr) 2006-04-28
FR2877118B1 (fr) 2007-01-19
US20070250703A1 (en) 2007-10-25
US8266423B2 (en) 2012-09-11

Similar Documents

Publication Publication Date Title
WO2006045924A1 (fr) Protection contre les attaques par generation de fautes sur les instructions de saut
EP1161725B1 (fr) Procede de surveillance du deroulement d&#39;un programme
EP1605333B1 (fr) Contrôle de l&#39;exécution d&#39;un programme
EP1904946B1 (fr) Detection d&#39;une faute par perturbation longue
EP1779284B1 (fr) Procédé et dispositif de traitement de données
FR2849226A1 (fr) Procede et dispositif de securisation de l&#39;execution d&#39;un programme informatique.
EP2158557B1 (fr) Procédé et dispositif de détection de sauts erronés au cours de l&#39;éxecution d&#39;un programme
EP3441902B1 (fr) Procédé de protection d&#39;un dispositif électronique contre des attaques par injection de faute
WO2017103497A1 (fr) Procédé d&#39;écriture dans une mémoire non-volatile d&#39;une entité électronique et entité électronique associée
WO2006067319A1 (fr) Procede et dispositif de remplissage de securisation d&#39;une memoire et memoire associee
WO2007077142A2 (fr) Procede de securisation de l&#39;execution d&#39;un programme d&#39;ordinateur
EP2860668B1 (fr) Procédé et dispositif de réalisation de fonction par un microcircuit
WO2007006887A1 (fr) Protection contre les attaques par generation de fautes sur les instructions de saut
EP3470999B1 (fr) Sécurisation d&#39;instructions de branchement conditionnel composé dans un programme informatique en code intermédiaire
EP2652664A1 (fr) Procede dynamique de controle de l&#39;integrite de l&#39;execution d&#39;un code executable
EP1442556B1 (fr) Procédé securisé de mise en oeuvre d&#39;un algorithme de cryptographie et composant correspondant
EP4177780A1 (fr) Procede de detection d&#39;une tentative d&#39;extraction lineaire du contenu d&#39;une memoire
FR3011650A1 (fr) Procede et dispositif de realisation de fonction par un microcircuit
FR3140186A1 (fr) Procédé de détection d’une tentative d’extraction linéaire du contenu d’une mémoire
EP2630605B1 (fr) Procede de securisation de l&#39;execution d&#39;un code informatique par redondance dynamique
EP2860669A1 (fr) Procédé mis en oeuvre dans un microcircuit et dispositif associé
WO2012172245A1 (fr) Transfert securise entre memoire non-volatile et memoire volatile
WO2023083776A1 (fr) Procédé de détection d&#39;une tentative d&#39;extraction linéaire du contenu d&#39;une mémoire
FR3030826A1 (fr) Procede de securisation d&#39;un dispositif electronique, et ledit dispositif electronique

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A1

Designated state(s): AE AG AL AM AT AU AZ BA BB BG BW BY BZ CA CH CN CO CR CU CZ DK DM DZ EC EE EG ES FI GB GD GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV LY MD MG MK MN MW MX MZ NA NG NO NZ OM PG PH PL PT RO RU SC SD SG SK SL SM SY TJ TM TN TR TT TZ UG US UZ VC VN YU ZA ZM

AL Designated countries for regional patents

Kind code of ref document: A1

Designated state(s): BW GH GM KE LS MW MZ NA SD SZ TZ UG ZM ZW AM AZ BY KG MD RU TJ TM AT BE BG CH CY DE DK EE ES FI FR GB GR HU IE IS IT LU LV MC NL PL PT RO SE SI SK TR BF BJ CF CG CI CM GA GN GQ GW MR NE SN TD TG

121 Ep: the epo has been informed by wipo that ep was designated in this application
NENP Non-entry into the national phase

Ref country code: DE

WWE Wipo information: entry into national phase

Ref document number: 11665991

Country of ref document: US

WWP Wipo information: published in national office

Ref document number: 11665991

Country of ref document: US

122 Ep: pct application non-entry in european phase

Ref document number: 05809270

Country of ref document: EP

Kind code of ref document: A1