EP4689899A1 - Verfahren zum betreiben einer recheneinheit in einem sicheren betriebsmodus - Google Patents

Verfahren zum betreiben einer recheneinheit in einem sicheren betriebsmodus

Info

Publication number
EP4689899A1
EP4689899A1 EP24716742.2A EP24716742A EP4689899A1 EP 4689899 A1 EP4689899 A1 EP 4689899A1 EP 24716742 A EP24716742 A EP 24716742A EP 4689899 A1 EP4689899 A1 EP 4689899A1
Authority
EP
European Patent Office
Prior art keywords
command
operating mode
check
instruction
executed
Prior art date
Legal status (The legal status 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 status listed.)
Pending
Application number
EP24716742.2A
Other languages
English (en)
French (fr)
Inventor
Dieter Thoss
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Robert Bosch GmbH
Original Assignee
Robert Bosch GmbH
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 Robert Bosch GmbH filed Critical Robert Bosch GmbH
Publication of EP4689899A1 publication Critical patent/EP4689899A1/de
Pending legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/08—Error detection or correction by redundancy in data representation, e.g. by using checking codes
    • G06F11/10—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's
    • G06F11/1004—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's to protect a block of data words, e.g. CRC or checksum
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; 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/57—Certifying or maintaining trusted computer platforms, e.g. secure boots or power-downs, version controls, system software checks, secure updates or assessing vulnerabilities
    • G06F21/575—Secure boot
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/28—Error detection; Error correction; Monitoring by checking the correct order of processing
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2221/00—Indexing scheme relating to security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F2221/03—Indexing scheme relating to G06F21/50, monitoring users, programs or devices to maintain the integrity of platforms
    • G06F2221/034—Test or assess a computer or a system

Definitions

  • the present invention relates to a method for operating a computing unit in a secure operating mode as well as a computing unit and a computer program for carrying out the method.
  • a functionally safe execution platform (referred to as a "safe island”, “vital modules”, “safe backbone” or “safe execution platform”) can be implemented in a computing unit such as a microcontroller or a system-on-a-chip (SoC) to enable software to be executed at the highest level of safety in terms of operational safety or functional safety.
  • this safety level can be ASIL-D, the highest safety requirement level for safety-relevant systems in motor vehicles in accordance with the safety standards of ISO 26262 or the ASIL (Automotive Safety Integrity Level) defined therein.
  • Such a functionally reliable execution platform can be implemented, for example, by providing two identical processor cores and operating them in the so-called lockstep process, whereby the two cores execute the same processes and check their results against each other for plausibility, and an error signal can be output if deviations are detected.
  • the cores usually have separate clock trees and separate areas on the respective chip.
  • Program code can be stored, for example, in an embedded NOR flash memory and data in an embedded static ROM memory.
  • Such a lockstep concept with an additional, redundant processor core is associated with high energy consumption and a large space requirement.
  • the lockstep concept cannot be implemented equally well for all types of processor.
  • the lockstep concept can be well suited for medium-performance cores, which are used for example for engine control or for controlling braking systems in vehicles.
  • the lockstep method often scales poorly.
  • High-performance cores can often only be operated in parallel lockstep mode to a limited extent.
  • NOR flash memories also often cannot be scaled to nodes below 28 nm and require more space than NAND flash.
  • Embedded static RAM can usually not contain more than 10 Miß (mebibytes).
  • the invention makes it possible to operate the computing unit in the safe operating mode in a safe manner with regard to operational safety or functional safety.
  • safety or safe is mentioned in the present context, this is to be understood in particular in the sense of operational safety or functional safety, which is referred to as "safety" in English, in contrast to information technology security or information security, which in English is referred to as "security”.
  • the computing unit has in particular a processor unit with one or more processor cores and a non-volatile memory unit, e.g. a (NAND) flash memory, and a volatile memory unit, e.g. a (LPDDR) RAM memory.
  • Software or program code is expediently stored in the non-volatile memory unit.
  • the software comprises individual commands or machine commands or instructions that were created by a compiler in particular during a compilation process. To execute them, the individual commands are read in by the processor unit from the volatile memory unit and executed.
  • regular operation or regular operating mode of the computing unit this reading or fetching of commands takes place in the conventional way.
  • the secure operating mode however, the reading takes place in a special way to enable secure operation of the computing unit.
  • an activation command for activating the secure operating mode is read in and executed by the processor unit as part of the method, in particular during the regular operating mode of the computing unit.
  • the secure operating mode of the processor unit is activated in response to this read activation command.
  • this activation command can be implemented using a compiler instruction or a pragma directive.
  • the respective read-in commands o n can then be executed by the processor unit.
  • a predetermined value eg zero
  • an initial check value pwo can be read in together with the activation command. Accordingly, the activation command can be enriched with the initial check value, for example as an argument of the command.
  • the current test value is checked at least once by the processor unit.
  • the current test value can be compared with an associated, previously calculated reference test value for this purpose.
  • the associated reference test value can also be stored in the non-volatile memory unit for each software command. Since the chain or series of commands is known in advance, the series of test values can also be predetermined.
  • the current test value can be checked at regular intervals or for special events.
  • the safe operating mode enables a functionally safe execution platform ("Safe Island”, “Vital Modules”, “Safe Backbone” or “Safe Execution Platform”) to be implemented in a low-effort, energy- and space-saving manner.
  • a functionally safe execution platform ("Safe Island”, “Vital Modules”, “Safe Backbone” or “Safe Execution Platform”
  • it is possible to run software at a high or highest safety level for example at the highest safety requirement level ASIL-D in accordance with the safety standards of ISO 26262 in the automotive sector.
  • the individual commands read in in the safe operating mode can be conveniently checked for correctness and integrity and it can also be assessed whether the individual commands were read in correctly.
  • a specified measure can be carried out, for example an error message can be issued or an entry can be created in an error memory, or the system can be stopped or transferred to a safe state if necessary.
  • an unsafe storage unit e.g. a conventional (NAND) flash memory or (LPDDR) RAM.
  • LPDDR LPDDR
  • insecure communication system e.g. an internal processor bus system.
  • the individual instructions are expediently enriched with a respective reference check value outside the computing unit, for example during the compilation process, and can then be checked in the computing unit during their reading by the processor core depending on this reference check value and the calculated check value, e.g. when a predetermined check event occurs. In this way, in particular, the integrity of the instructions from the compiler to the processor core can be guaranteed.
  • the method is suitable, for example, for all processor units and logic units that process a program and read instructions from a memory.
  • the method is also suitable for high-performance cores and for systems with large program code and large amounts of data, such as those used for autonomous driving.
  • no special hardware units are required to implement the safe operating mode; conventional memory units and buses can be used, for example.
  • no implementation of error detection methods (EDC) or error correction methods (ECC) in hardware is required.
  • EDC error detection methods
  • ECC error correction methods
  • a large external RAM memory can be used and connected to the processor unit via a conventional standard interface, e.g. via a JEDEC LPDDR interface.
  • a conventional external NAND flash can be used, for example, to write program code and initialization data to the RAM memory.
  • the safe operating mode can conveniently be activated and deactivated at any time as required.
  • the secure mode does not require embedded NOR flash memory and embedded static ROM memory. Additional logic for the processor core, as well as additional instructions and control and status registers, may be required for the secure mode. (English “Control and Status Register”, CSR), which may result in a slightly increased space requirement on the chip, but significantly less space requirement than would be the case for a separately secured memory.
  • CSR Control and Status Register
  • the check values can each be calculated according to a cyclic redundancy check (CRC).
  • CRC cyclic redundancy check
  • the length of the individual check values can, for example, be selected in such a way that such a check value can be integrated as an immediate value in the activation command. Since the check value calculation takes place with each command call, which in particular runs at full core clock, the calculation takes place in a single clock cycle, at least for 16- and 32-bit commands.
  • the check values can also be used for 64-bit commands and longer commands.
  • the check values cover at least 128 32-bit instructions (4096 program memory bits), e.g. in order not to use up too much program space and runtime.
  • the check value can thus be calculated continuously, but a pre-calculated comparison value only exists every 128 commands.
  • a calculation scheme for the test value calculation can be expediently specified in such a way that the hardware effort and power consumption for the calculation are as low as possible. Furthermore, the calculation scheme can be specified in such a way that different sequences of the same commands expediently lead to different test values.
  • the test values should expediently detect every possible combination of bit errors with at least 99%.
  • the so-called Hamming weight i.e. the number of undetected errors, for any number of bit errors is in particular less than or equal to 1% of the number of possible errors.
  • the (then) current test value is checked in the safe operating mode when a predetermined check event occurs.
  • the predetermined checking event comprises reading in a predetermined checking instruction.
  • a checking instruction can be a special machine instruction to instruct the processor unit to check the current check value.
  • Such a checking instruction can be conveniently generated at any time as required or in response to a special triggering event, e.g. after a predetermined number of instructions have been read in.
  • a predetermined error detection time can be maintained and it can be prevented, for example, that too many instructions are read in and not checked, reducing error coverage, i.e. the probability of being able to detect every combination of errors.
  • checking instructions can be generated during the compilation process and conveniently placed at a suitable point in the instruction sequence.
  • the checking instruction can be enriched with a reference value.
  • the predetermined checking event comprises reading in a jump command to execute a jump in the program flow.
  • a jump command instructs the processor unit to jump to a specific command of the program code or to a corresponding memory address and to execute this or the command there.
  • Such a jump can in principle lead anywhere, even to a potentially dangerous destination.
  • a check of the current check value can expediently be carried out with each jump, in the course of which in particular the check value calculated from the jump command itself is checked.
  • the predetermined check event comprises reading in a subroutine command for executing a subroutine.
  • the processor unit can be expediently instructed, similar to a jump command, to execute special commands of a specific program code module.
  • a check can be carried out.
  • the reading in of a respective Subroutine command a check of the then current test value must be carried out.
  • the specified checking event includes reading in a branch instruction for executing multiple branches of instructions.
  • a branch instruction can instruct the processor unit to split a regular, linear program sequence.
  • a check of the then current check value can expediently be carried out.
  • a predetermined measure is carried out if no check of the current test value has been carried out after a predetermined maximum number of commands have been read in and/or after a predetermined maximum time interval has elapsed. If, for example, no check has been carried out after 100 commands have been read in and/or after one microsecond, an error message can be issued as a measure, for example a timeout error.
  • a deactivation command for deactivating the safe operating mode is read in the safe operating mode, in particular to end it.
  • the current test value is then calculated from this deactivation command and the previous test value and this current test value is checked. It can thus be finally determined that the safe operating mode was error-free.
  • the safe operating mode can be deactivated by the processor unit and the computing unit can be operated in the regular operating mode again.
  • this deactivation command can also be implemented using a compiler instruction or pragma directive, corresponding to the activation command.
  • a first test value is calculated from a first command currently to be executed and a predetermined initial test value or a read-in initial test value as the previous test value.
  • the Checking the respective current test value based on this first test value.
  • the test value calculation can be initialized with this initial value in such a way that the test value that is checked during deactivation corresponds to a predetermined expected value in an error-free case, e.g. the value zero.
  • the test value calculation can also be initialized with a predetermined initial value, e.g. zero, whereby the final value in an error-free case then corresponds to a value that can be precalculated with knowledge of the command chain.
  • commands to be read in are each provided with a reference check value before activating the safe operating mode.
  • These reference check values are particularly expediently created in the course of a compilation process of the program code in the executable machine code.
  • the commands to be read in are expediently loaded together with the respective reference check value into the volatile memory unit, from which the individual commands are read in the safe operating mode together with the reference check value.
  • the check of the respective current check value calculated from a respective read-in command in the course of the safe operating mode can then be carried out depending on the respective reference check value of this respective command, in particular by comparing the corresponding current check value with the respective reference check value.
  • the current check value is modified in the secure operating mode if a number of instructions are skipped and not executed and/or if a number of instructions that have already been executed are executed again, for example by executing a corresponding jump or branch instruction. In such a case, if individual instructions are skipped or repeated, the check value check may be incorrect, even though all instructions were read in and executed correctly and as specified. To prevent this, the current check value is modified or changed using a modification instruction. If a number of instructions are not executed during a jump, a first modification instruction is read in and executed by the processor unit. This first modification command, for example, using an argument of the first modification command, modifies the current test value as if the individual skipped commands had been executed.
  • a second modification command is read in.
  • This second modification command or an argument of this command modifies the current test value as if the individual commands that have been executed again had only been executed once.
  • the respective modification command can be created during the compilation process and inserted into the command sequence at a suitable point.
  • the computing unit has a processor unit based on a RISC-V instruction set architecture (ISA).
  • An instruction set generally refers to the totality of machine instructions that a processor unit can execute.
  • the RISC-V instruction set architecture is based on the so-called RISC principle (Reduced Instruction Set Computer, RISC), according to which the instruction set comprises a small number of instructions, usually less than 100, which can each be processed easily and quickly by the processor unit, thereby achieving a simplified processor design, high processor clock speed and fast execution speed, in contrast to the so-called CISC architecture (Complex Instruction Set Computing, CISC), which provides an instruction set with a high number of instructions (over 100) through which a respective processor can execute complex processes, but this is associated with a complex processor design.
  • RISC Reduced Instruction Set Computer
  • the RISC-V instruction set architecture is an open standard or "open source” and makes it easy to make changes and extensions to the instruction set.
  • RISC-V processors or, in general, processors with a modifiable instruction set architecture are therefore particularly suitable for implementing the secure operating mode, since the instructions required to execute the secure operating mode, such as the activation, deactivation, checking or modification instructions, can be easily integrated into the instruction set.
  • the method is particularly suitable for use in the vehicle sector.
  • the computing unit can in particular be designed as a microcontroller or control unit in a (motor) vehicle.
  • Processes carried out by the computing unit can, for example, include safety-critical functions which are carried out for the safe operation and control of the vehicle, for example in the course of engine control, in the course of driver assistance functions or also in the course of autonomous driving, etc.
  • the safety or reliability and integrity of the control unit can be increased by the present method.
  • the method can meet safety requirements in the (motor) vehicle sector, as specified, for example, in the ISO 26262 standard or in particular by the so-called "Automotive Safety Integrity Level” (ASIL), a safety requirement level for safety-relevant systems in motor vehicles specified by ISO 26262.
  • ASIL Automaticmotive Safety Integrity Level
  • a computing unit according to the invention e.g. a control unit of a motor vehicle, is set up, in particular in terms of programming, to carry out a method according to the invention.
  • a machine-readable storage medium is provided with a computer program stored on it as described above.
  • Suitable storage media or data carriers for providing the computer program are in particular magnetic, optical and electrical memories, such as hard disks, flash memories, EEPROMs, DVDs, etc.
  • Figure 1 shows schematically an embodiment of a computing unit according to the invention, which is set up to carry out an embodiment of a method according to the invention.
  • Figure 2 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 3 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 4 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 5 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 6 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 7 shows schematically an embodiment of a method according to the invention as a block diagram.
  • Figure 8 shows schematically an embodiment of a method according to the invention as a block diagram. embodiment(s) of the invention
  • a computing unit is shown schematically and designated with 100, which can be designed, for example, as a system-on-a-chip (SoC).
  • SoC system-on-a-chip
  • the SoC 100 can be provided for a motor vehicle and integrated into a control unit of the vehicle, for example in order to carry out safety-critical functions for the safe operation of the vehicle, e.g. in the course of engine control, in the course of driver assistance functions, in the course of autonomous driving, etc.
  • the SoC 100 is set up, in particular in terms of programming, to carry out an embodiment of a method according to the invention.
  • the SoC 100 can be operated in a safe operating mode in which a safe retrieval of commands is made possible.
  • a functionally safe execution platform 110 ("Safe Island”, “Vital Modules”, “Safe Backbone” or "Safe Execution Platform" is implemented in the SoC 100.
  • a processor unit 111 a cache logic unit 112 and a timer 113 are provided for this functionally reliable execution platform 110 or for executing the secure operating mode.
  • the processor unit 111 can expediently (but not restrictively) be a processor core based on a RISC-V instruction set architecture.
  • This RISC-V processor 111 and the cache logic unit 113 are connected, for example, via RAM and cache memory 121 to an interconnect 120 of the SoC 100 as further elements of the functionally reliable execution platform 110.
  • a flash memory unit 140 eg a NAND flash memory, can be connected to the connection unit 120 via an interface 141 and a RAM memory unit 150, eg an LPDDR RAM, via a RAM controller 151.
  • the SoC 100 can also have one or more further processor cores 130 with associated RAM and cache memory 131 which are connected to the connection unit 120.
  • a memory unit 122 as a further element of the functionally reliable execution platform 110 for a start process (boot flash memory) and a peripheral bus 160 can be connected to the connection unit 120.
  • a large number of peripheral units can be connected to the peripheral bus 160, e.g. an analog-digital converter 161, a serial bus system 162 ("Serial Peripheral Interface", SPI), a unit for direct memory access 163 ("Direct Memory Access", DMA), a timer 164 and a further field bus system 165, e.g. a Flexray field bus.
  • peripheral units can be provided, indicated by reference numeral 166.
  • an external monitoring unit 180 for detecting and managing an error or failure of the SoC 100 can be connected via the serial bus system 162.
  • the SoC 100 can also have an error management unit 170 ("error management module", EMM) for managing output error messages.
  • EMM error management module
  • the processor 111 calculates and checks check values of read-in instructions in order to ensure the integrity of the instructions from a compiler to the processor core 111, as will be explained below with reference to Figures 2 to 8.
  • FIG. 2 to 8 an embodiment of the method according to the invention is shown schematically as a block diagram.
  • the individual Figures 2 to 8 each show a sequence of commands which can be read in and executed by the processor 111.
  • These individual commands are generated, for example, by a compiler during a compilation process of a program code, with a reference check value being calculated for each command generated.
  • These commands can be stored together with the respective reference check value, for example, in the flash memory unit 140 and copied from there into the RAM memory unit 150 during operation of the SoC 100.
  • at least one of the commands expediently the first or the last of those to be safely executed, is stored together with the reference check value. for example, as an argument of the command.
  • several or all commands are stored with their reference check value.
  • the individual commands can be read from the RAM memory 150 together with the respective reference check value by the processor 111 in the course of a command fetch ("instruction fetch") and executed.
  • instructions 202, 204 and 206 are read in and executed by the processor 111 in a regular manner. During this regular operating mode, no check value is calculated for the instructions read in.
  • an activation instruction 208 is read in, the processor 111 activates the secure operating mode. From then on, until the secure operating mode is deactivated, the processor 111 calculates a current check value from each instruction read in and the previous check value.
  • a first test value is calculated in particular from a first command currently to be executed and a predetermined initial test value or a read-in initial test value as the previous test value.
  • the test value calculation can be initialized with a read-in initial test value in such a way that a final value to be calculated later should correspond to a predetermined value in an error-free case, e.g. zero.
  • the processor 111 After activating the secure operating mode, the processor 111 reads in a command 210 and calculates the current check value from this command 210 and from the initial check value. The processor 111 then reads in the next command 212 and calculates the current check value from this command 212 and from the previous check value.
  • This command 212 is, for example, a subroutine command for executing a subroutine.
  • the processor 111 executes the corresponding subroutine or a corresponding program code module.
  • the processor 111 reads in the commands 218, 220, 222, 224, 226, 228, 230 and 232 and calculates the current test value from the respective read instruction and the respective previous check value.
  • the instruction 232 can, for example, be a return instruction which characterizes the end of the subroutine and instructs the processor 111 to return to the previous instruction sequence.
  • the processor 111 In response to the return command 232, the processor 111 reads in the commands 214 and 216 and calculates the current test value.
  • the command 216 can be, for example, a jump command to jump to a specific command 234 or to its memory address in the RAM 150.
  • the processor 111 then reads in this command 234 and calculates the current test value.
  • the next command 236 read in can, for example, again be a subroutine command.
  • the processor 111 again reads in the individual commands 218, 220, 222, 224, 226, 228, 230 and 232 of this module and calculates the current test value in each case.
  • the processor 111 Upon re-reading the return command 232, the processor 111 returns to the previous command sequence and reads the commands 238 and 240 and calculates the current test value in each case.
  • the command 240 is, for example, a deactivation command for deactivating the safe operating mode.
  • the processor 111 deactivates the safe operating mode.
  • the processor 111 carries out a check of the current test value. In the course of this, a check is made as to whether the current test value calculated from the deactivation command 240 corresponds as a final value, for example, to the specified value zero.
  • this final value is not zero, this indicates an error and a predetermined action is taken, e.g., issuing an error message or stopping the system or placing it in a safe state. If, on the other hand, the final value is zero, this indicates that no error has occurred.
  • the processor 111 then returns to the regular operating mode. In the process, the processor 111 reads in the instructions 242 and 244 without calculating a check value.
  • a check of the current check value can also be carried out during the secure operating mode, as explained below with reference to Figure 3. For example, if the subroutine is large or is compiled from a different source file than the rest of the instructions, a check of the check value when starting this subroutine during the secure operating mode can be expedient.
  • the processor 111 reads in the commands 302, 304 and 306 without calculating a check value.
  • the next command 308 read in is, for example, the activation command, after which the secure operating mode is activated.
  • the processor 111 calculates the current check value from each command read in and initializes the check value calculation with an initial check value in response to the activation command 306.
  • the processor 111 In the safe operating mode, the processor 111 first reads in the command 310 and then the subroutine command 312, after which the subroutine is executed. In this subroutine, the processor 111 first reads in a check command 320, after which the processor 111 carries out a check of the current check value. In this way, the read-in subroutine command 312 can be checked, in particular immediately after it has been executed. For this check, the processor 111 compares the check value calculated from the subroutine command 312, for example, with the specified value zero.
  • the processor 111 reads the next instruction 322 and calculates the current check value from this instruction 322 and the previous check value (here zero).
  • the processor 111 then reads the instructions 324, 326, 328, 330, 332 and 334 of the subroutine and calculates the current test value in each case.
  • the instruction 334 is, for example, a return instruction, whereupon the processor 111 returns to the previous instruction sequence and executes the instruction 314.
  • This instruction 314 is also, for example, a check instruction, whereupon the processor 111 carries out another check of the current check value. In this way, the subroutine or its individual commands can be checked, in particular immediately after their execution. Following this check, the processor also reinitializes the check value calculation by reading in the next command 316 with a new initial check value.
  • the processor 111 then reads in the command 318, whereby this command 318 is, for example, a jump command, whereupon the processor 111 jumps to the command 336 and reads it in.
  • the processor 111 then reads in the command 338, which is, for example, again a subroutine command.
  • the processor 111 now reads in the command 320 again, carries out a check of the current test value, and reinitializes the test value calculation with the command 322.
  • the processor 111 then reads in the other commands 324, 326, 328, 330, 332 and 334 of the subroutine again, returns to the previous command sequence on the return command 334 and reads in the command 340.
  • This command 340 is also a check command, on which the processor 111 carries out a check of the current test value.
  • the processor 111 then reads commands 342, 344 and 346, where command 346 is the deactivation command and the secure mode of operation is deactivated. Also in response to the deactivation command 346, the processor 111 performs a check of the current check value. The processor 111 then returns to the regular mode of operation and reads commands 348 and 350 without calculating a check value.
  • a check of the current test value can also be carried out in response to a jump command, as explained below with reference to Figure 4. Since jump commands can in principle also lead to a potentially dangerous destination, it can be expedient to carry out a check with a jump.
  • the processor 111 is already in the secure operating mode and reads in the commands 402, 404, 406 and 408 and calculates the current test value in each case.
  • the command 408 is For example, it could be a jump instruction to perform an indirect jump to several addresses or to several other instructions 410, 416 and 424.
  • the processor 111 then reads in these instructions 410, 416 and 424 and calculates the current test value for each one.
  • each of these instructions 410, 416 and 424 is a check instruction, whereupon the processor 111 carries out a check of the respective current test value.
  • the read jump instruction 408 can be checked immediately after it has been executed.
  • the processor 111 reads in the individual instructions 412, 414, 418, 420, 422, 426, 428 and 430 and calculates the current test value for each one.
  • the instruction 408 can also be a subroutine instruction in order to execute several subroutines in the course of an indirect function call.
  • the instructions 410, 412 and 414 characterize a first subroutine
  • the instructions 416, 418, 420 and 422 a second subroutine
  • the instructions 424, 426, 428 and 430 a third subroutine.
  • the respective last instructions 414, 422 and 430 of the individual subroutines can each be a return instruction.
  • a check of the current check value may also be performed upon a branch instruction for executing multiple branches of instructions, as explained below with reference to Figure 5.
  • the processor 111 is already in the secure operating mode, during which the processor 111 reads in the commands 502, 504 and 506 and calculates the current test value in each case.
  • the command 506 is, for example, a branching command (eg If - then) to read in and execute the commands 508, 510, 512, 514 and 516 as a first branch and to read in and execute the commands 520, 522, 524, 526, 528, 530 and 532 as a second branch.
  • the processor 111 then reads in the respective first command 508 or 518 of these two branches, whereby these commands 508 or 518 are each a check command, whereupon the processor 111 carries out a check of the current check value.
  • the processor 111 then reads in the remaining commands of the two branches.
  • the respective last instruction 516 or 532 of the two branches is, for example, a jump instruction to jump to instruction 534.
  • the two branches thus merge again and the processor 111 reads this instruction 534 as well as the subsequent instructions 536 and 538.
  • instructions in the auxiliary sequence can be skipped or executed again in the course of a loop, as explained below with reference to Figures 6a and 6b.
  • the processor 111 is already in the secure operating mode and reads in the commands 602, 604 and 606 and calculates the current check value for each.
  • the command 606 is a jump command to not execute the commands 608, 610 and 612 and to jump to the command 614.
  • the command 608 to be skipped can be a check command.
  • the processor 111 Upon reading the jump instruction 606, the processor 111 reads the instruction 614, which is, for example, a check instruction, and performs the corresponding check. The processor then continues with the instruction flow and reads the instruction 616.
  • the instruction 614 which is, for example, a check instruction
  • the processor 111 is also in the secure operating mode, reads the commands 650, 652, 654, 656, 658, 660, 662, 664 and 666 and calculates the current test value for each one.
  • the commands 652 and 660 are each a check command, for example.
  • the command 666 is a jump command to return to the check command 660 and to read the commands 660, 662 and 664 again.
  • the processor 111 reads the commands 668, 670, 672, 674 and 676.
  • instruction 668 is also a check instruction.
  • instruction 676 is a jump instruction to return to check instruction 652 and to read instructions 652 to 674 again.
  • Processor 111 then continues with instructions 678, 680 and 682, with instruction 678 also being a check instruction.
  • the current test value when omitting or repeating individual commands, can also be modified by means of a modification command, as explained below with reference to Figures 7a and 7b.
  • the processor 111 is in the secure operating mode, reads in the instructions 702, 704, 706, 708 and 710 and calculates the current check value in each case, wherein the instruction 710 is a jump instruction to not execute the instructions 712, 714 and 716 and to jump to the instruction 718.
  • the instruction 704 is a first modification instruction by which the current check value is modified in such a way as if the individual instructions 712, 714 and 716 that were not executed had nevertheless been executed.
  • the processor 111 is also in the secure operating mode and reads in the instructions 750, 752, 754, 756, 758, 760, 762, 764 and 766 and calculates the current test value in each case.
  • the instruction 766 is a jump instruction to return to the instruction 760 and to read in the instructions 760, 762 and 764 again.
  • the instruction 758 is a second modification instruction, by which the current test value is modified in such a way as if the individual instructions 760, 762 and 764 that were executed again had only been executed once.
  • processor 111 After re-reading instructions 760, 762 and 764, processor 111 reads instructions 768, 770, 772, 774 and 776. Instruction 776 is also a jump instruction to return to instruction 752 and re-read instructions 752 to 774. Instruction 770 is also a second modification instruction, by which the current test value is modified as if the individual re-executed instructions 752 to 774 had been executed only once. After re-reading these instructions 752 through 774, the processor 111 proceeds to read the next instructions 778, 780, and 782. For example, instruction 780 is also a second modify instruction to modify the current check value for a subsequent jump instruction.
  • the processor 111 is in the secure operating mode, reads the instructions 802, 804, 806, 808 and 810 and calculates the current check value for each, where the instruction 810 is a jump instruction to not execute the instructions 812, 814 and 816 and jump to the instruction 818.
  • the instruction 804 is a modify instruction, by which the current check value is not modified, however, for the immediately next jump instruction 810.
  • the instructions 812 and 818 can each be a check instruction.
  • the processor 111 is also in the secure operating mode and reads the instructions 850, 852, 854, 856, 858, 860, 862, 864 and 866 and calculates the current check value in each case.
  • the instruction 866 is a jump instruction to return to the instruction 860 and to read the instructions 860, 862 and 864 again.
  • the instruction 852 is, for example, a check instruction.
  • the instruction 858 is a second modification instruction by which the current check value is modified as if the re-executed instructions 860, 862 and 864 had only been executed once.
  • processor 111 After rereading instructions 860, 862 and 864, processor 111 reads instructions 868, 870, 872, 874 and 876, with instruction 876 being a jump instruction to return to check instruction 852. Processor 111 now rereads instructions 852 to 874 and then continues with instructions 878, 880 and 882.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Computer Security & Cryptography (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Software Systems (AREA)
  • Quality & Reliability (AREA)
  • Test And Diagnosis Of Digital Computers (AREA)
  • Hardware Redundancy (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

Die Erfindung betrifft ein Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus, umfassend ein Einlesen eines Aktivierungsbefehls (208) zum Aktivieren eines sicheren Betriebsmodus, ein Aktivieren des sicheren Betriebsmodus auf den eingelesenen Aktivierungsbefehl hin; in dem sicheren Betriebsmodus, ein Einlesen von Befehlen und Berechnen jeweils eines aktuellen Prüfwerts aus einem aktuell auszuführenden Befehl und einem vorherigen Prüfwert; und in dem sicheren Betriebsmodus, wenigstens einmal ein Überprüfen des aktuellen Prüfwerts.

Description

Beschreibung
Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus
Die vorliegende Erfindung betrifft ein Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus sowie eine Recheneinheit und ein Computerprogramm zu dessen Durchführung.
Hintergrund der Erfindung
In einer Recheneinheit wie einem Mikrocontroller oder einem System-on-a-Chip (SoC) kann eine funktionssichere Ausführungsplattform implementiert sein (im Englischen beispielsweise als "Safe Island", "Vital Modules", "Safe Backbone" oder "Safe Execution Platform" bezeichnet), um eine Ausführung von Software auf höchstem Sicherheitsniveau in Bezug auf die Betriebssicherheit bzw. funktionale Sicherheit (engl. "safety") zu ermöglichen. Beispielsweise kann dieses Sicherheitsniveau im Automobilbereich ASIL-D sein, die höchste Sicherheitsanforderungsstufe für sicherheitsrelevante Systeme in Kraftfahrzeugen gemäß den Sicherheitsstandards der ISO 26262 bzw. den darin definierten ASIL (Automotive Safety Integrity Level).
Eine derartige funktionssichere Ausführungsplattform kann beispielsweise realisiert sein, indem zwei identische Prozessorkerne vorgesehen und im sog. Lockstep-Verfahren betrieben werden, wobei die beiden Kerne die gleichen Prozesse ausführen und ihre Ergebnisse gegeneinander plausibilisieren und wobei bei erkannten Abweichungen ein Fehlersignal ausgegeben werden kann. Die Kerne haben zumeist getrennte Taktbäume und getrennte Bereiche auf dem jeweiligen Chip. Programmcode kann beispielsweise in einem eingebetteten NOR- Flash-Speicher hinterlegt sein und Daten in einem eingebetteten statischen ROM-Speicher. Ein derartiges Lockstep-Konzept mit einem zusätzlichen, redundanten Prozessorkern ist jedoch mit hohem Energieverbrauch und hohem Platzbedarf verbunden. Ferner lässt sich das Lockstep-Konzept nicht bei allen Prozessorarten gleich gut implementieren. Beispielsweise kann sich das Lockstep-Konzept gut für Kerne mittlerer Leistung eignen, welche beispielsweise zur Motorsteuerung oder zur Steuerung von Bremssystemen in Fahrzeugen verwendet werden. Bei höheren Leistungen kann das Lockstep-Verfahren jedoch oftmals schlecht skalieren. Hochleistungskerne können oftmals nur bedingt in parallelem Lockstep-Be- trieb betrieben werden. Auch lassen sich NOR-Flash-Speicher oftmals nicht auf Knoten unter 28 nm skalieren und benötigen mehr Fläche als NAND-Flash. Eingebetteter statischer RAM kann zumeist nicht mehr als 10 Miß (Mebibyte) umfassen.
Funktionssichere Ausführungsplattform basierend auf dem Lockstep-Prinzip eignen sich daher oftmals nur bedingt für Systeme mit großem Programmcode und großen Datenmengen, wie es beispielsweise im Zuge des autonomen Fahrens der Fall ist.
Offenbarung der Erfindung
Erfindungsgemäß werden ein Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus sowie eine Recheneinheit und ein Computerprogramm zu dessen Durchführung mit den Merkmalen der unabhängigen Patentansprüche vorgeschlagen. Vorteilhafte Ausgestaltungen sind Gegenstand der Unteransprüche sowie der nachfolgenden Beschreibung.
Die Erfindung ermöglicht es, die Recheneinheit in dem sicheren Betriebsmodus auf eine sichere Weise in Bezug auf die Betriebssicherheit bzw. funktionale Sicherheit (engl. "safety") zu betreiben. Wenn in dem vorliegenden Zusammenhang von Sicherheit bzw. sicher die Rede ist, sei dies insbesondere im Sinne einer Betriebssicherheit bzw. funktionalen Sicherheit zu verstehen, welche im Englischen als "safety" bezeichnet wird, im Gegensatz zu einer informationstechnischen Sicherheit bzw. Informationssicherheit, welche im Englischen als "security" bezeichnet wird.
Die Recheneinheit weist insbesondere eine Prozessoreinheit mit einem oder mehreren Prozessorkernen auf sowie eine nicht-flüchtige Speichereinheit, z.B. einen (NAND-) Flash-Speicher, und eine flüchtige Speichereinheit, z.B. einen (LPDDR-) RAM-Speicher. In der nicht-flüchtigen Speichereinheit ist zweckmäßigerweise eine Software bzw. ein Programmcode hinterlegt. Die Software umfasst einzelne Befehle bzw. Maschinenbefehle oder Instruktionen, die insbesondere im Zuge eines Kompilierprozesses durch einen Compiler erstellt wurden. Zur Ausführung werden die einzelnen Befehle durch die Prozessoreinheit aus der flüchtigen Speichereinheit eingelesen und ausgeführt. Im Zuge eines regulären Betriebs bzw. regulären Betriebsmodus der Recheneinheit erfolgt dieses Einlesen bzw. Abrufen (engl. "fetch") von Befehlen auf herkömmliche Weise. Im Zuge des sicheren Betriebsmodus hingegen erfolgt das Einlesen auf eine spezielle Weise, um einen sicheren Betrieb der Recheneinheit zu ermöglichen.
Zu diesem Zweck wird im Rahmen des Verfahrens ein Aktivierungsbefehl zum Aktivieren des sicheren Betriebsmodus durch die Prozessoreinheit eingelesen und ausgeführt, insbesondere während des regulären Betriebsmodus der Recheneinheit. Auf diesen eingelesenen Aktivierungsbefehl hin wird der sichere Betriebsmodus der Prozessoreinheit aktiviert. Beispielsweise kann dieser Aktivierungsbefehl mittels einer Compiler-Anweisung bzw. einer Pragma-Direktive (engl. "pragma directive") implementiert werden.
In dem sicheren Betriebsmodus werden Befehle durch die Prozessoreinheit eingelesen, insbesondere aus der flüchtigen Speichereinheit, insbesondere jeweils im Zuge eines Befehlsabrufs (engl. "fetch", "instruction fetch"), und es wird jeweils ein aktueller Prüfwert aus einem aktuell auszuführenden Befehl und einem vorherigen Prüfwert durch die Prozessoreinheit berechnet, insbesondere gemäß einem Prüfwertberechnungsschema pwn=f(on, pwn-i), wobei der Prüfwert pwn eine Funktion f des vorherigen Prüfwerts pwn-i und des aktuellen Befehls on ist. Die jeweiligen eingelesenen Befehle on können dann durch die Prozessoreinheit ausgeführt werden. Existiert beim ersten Aufruf (n=1) noch kein vorheriger Prüfwert pwo, kann dafür beispielsweise ein vorbestimmter Wert (z.B. null) verwendet werden, oder ein Initialprüfwert pwo kann zusammen mit dem Aktivierungsbefehl eingelesen werden. Dementsprechend kann der Aktivierungsbefehl mit dem Initialprüfwert angereichert sein, beispielsweise als Argument des Befehls.
In dem sicheren Betriebsmodus wird wenigstens einmal der dann aktuelle Prüfwert durch die Prozessoreinheit überprüft. Beispielsweise kann zu diesem Zweck der aktuelle Prüfwert mit einem zugehörigen vorab berechneten Referenzprüfwert verglichen werden. Dazu kann für jeden Befehl der Software auch der zugehörige Referenzprüfwert in der nicht-flüchtigen Speichereinheit hinterlegt sein. Da die Kette bzw. Reihe der Befehle vorbekannt ist, kann auch die Reihe der Prüfwerte vorbestimmt werden. Beispielsweise kann der jeweils aktuelle Prüfwert in regelmäßigen Zeitabständen oder zu speziellen Ereignissen überprüft werden.
Durch den sicheren Betriebsmodus kann auf eine aufwandsarme, energie- und platzsparende Weise eine funktionssichere Ausführungsplattform ("Safe Island", "Vital Modules", "Safe Backbone" oder "Safe Execution Platform") implementiert werden. In dem sicheren Betriebsmodus kann es ermöglicht werden, Software auf einem hohen oder höchsten Sicherheitsniveau auszuführen, beispielsweise auf der höchsten Sicherheitsanforderungsstufe ASIL-D gemäß den Sicherheitsstandards der ISO 26262 im Automobilbereich. Mit Hilfe der Prüfwerte können die einzelnen eingelesenen Befehle in dem sicheren Betriebsmodus zweckmäßigerweise auf Richtigkeit und Integrität überprüft werden und es kann ferner beurteilt werden, ob die einzelnen Befehle korrekt eingelesen wurden. Wenn im Zuge der Prüfwerteüberprüfung ein Fehler erkannt wird, kann eine vorgegebene Maßnahme durchgeführt werden, beispielsweise kann eine Fehlermeldung ausgegeben werden oder ein Eintrag in einem Fehlerspeicher erstellt werden, oder das System ggf. auch angehalten oder in einen sicheren Zustand überführt werden. In dem sicheren Betriebsmodus kann insbesondere ein sicheres Einlesen von Befehlen ermöglicht werden, auch aus einer unsicheren Speichereinheit heraus, z.B. einem herkömmlichen (NAND-)Flash-Speicher oder (LPDDR-)RAM- Speicher, auch über ein unsicheres Kommunikationssystem, z.B. ein internes Prozessorbussystem.
Zweckmäßigerweise werden die einzelnen Befehle außerhalb der Recheneinheit mit einem jeweiligen Referenzprüfwert angereichert, beispielsweise beim Kompiliervorgang, und können dann in der Recheneinheit im Zuge ihres Einlesens abhängig von diesem Referenzprüfwert und dem berechneten Prüfwert durch den Prozessorkern überprüft werden, z.B. bei Eintritt eines vorgegebenen Überprüfungsereignisses. Auf diese Weise kann insbesondere eine Integrität der Befehle von dem Compiler bis zu dem Prozessorkern gewährleistet werden.
Das Verfahren eignet sich beispielsweise für alle Prozessoreinheiten und Logikeinheiten, die ein Programm abarbeiten und dazu Instruktionen aus einem Speicher auslesen. Insbesondere eignet sich das Verfahren auch für Hochleistungskerne sowie für Systeme mit großem Programmcode und großen Datenmengen, wie sie beispielsweise für das autonome Fahren eingesetzt werden. Zum Realisieren des sicheren Betriebsmodus werden insbesondere keine speziellen Hardwareeinheiten benötigt, es können beispielsweise herkömmliche Speichereinheiten und Busse verwendet werden. Ferner wird insbesondere keine Implementierung von Fehlererkennungsverfahren (engl. "Error Detection Code", EDC) oder Fehlerkorrekturverfahren (engl. "Error Correcting Code", ECC) in Hardware benötigt. Beispielsweise kann ein großer externer RAM-Speicher verwendet und über eine herkömmliche Standard-Schnittstelle an die Prozessoreinheit angebunden werden, z.B. über eine JEDEC-LPDDR-Schnittstelle. Ferner kann beispielsweise ein herkömmlicher externer NAND-Flash verwendet werden, um Programmcode und Initialisierungsdaten in den RAM-Speicher zu schreiben. Der sichere Betriebsmodus kann zweckmäßigerweise jederzeit bedarfsweise aktiviert und deaktiviert werden.
Zwar kann der Programmcode durch die zusätzlichen Referenzprüfwerte mehr Speicherplatz benötigen, jedoch wird für den sicheren Betriebsmodus kein eingebetteter NOR-Flash-Speicher und eingebetteter statischen ROM-Speicher benötigt. Es können für den sicheren Betriebsmodus eine zusätzliche Logik für den Prozessorkern sowie zusätzliche Anweisungen und Kontroll- und Statusregister (engl. "Control and Status Register", CSR) vorgesehen sein, was zu einem leicht erhöhten Platzbedarf auf dem Chip führen kann, jedoch deutlich weniger Platzbedarf, als es für einen separat abgesicherten Speicher der Fall wäre..
Beispielsweise können die Prüfwerte jeweils gemäß einer zyklischen Redundanzprüfung (engl. "Cyclic Redundancy Check", CRC) berechnet werden. Die Länge der einzelnen Prüfwerte kann beispielsweise derart gewählt werden, dass ein derartiger Prüfwert als unmittelbarer Wert in den Aktivierungsbefehl integriert werden kann. Da die Prüfwertberechnung bei jedem Befehlsabruf erfolgt, welcher insbesondere mit vollem Kerntakt abläuft, erfolgt die Berechnung insbesondere zumindest bei 16- und 32-Bit-Befehlen in einem einzigen Taktzyklus. Die Prüfwerte sind zweckmäßigerweise auch auf 64-Bit-Befehle und auf längere Befehle anwendbar. Die Prüfwerte decken insbesondere mindestens 128 32-Bit-Anwei- sungen (4096 Programmspeicherbits) ab, z.B. um nicht zu viel Programmplatz und Laufzeit zu verbrauchen. Insbesondere kann somit der Prüfwert zwar laufend berechnet werden, aber nur alle 128 Befehle ein vorberechneter Vergleichswert existieren. Ein Berechnungsschema für die Prüfwertberechnung kann zweckmäßigerweise derart vorgegeben werden, dass Hardware-Aufwand und Leistungsaufnahme für die Berechnung möglichst gering sind. Ferner kann das Berechnungsschema derart vorgegeben werden, dass unterschiedliche Sequenzen gleicher Befehle zweckmäßigerweise zu unterschiedlichen Prüfwerten führen. Um beispielsweise das ASIL-D-Sicherheitsniveau zu erfüllen, sollen die Prüfwerte zweckmäßigerweise jede mögliche Kombination von Bit-Fehlern mit mindestens 99 % erkennen. Das sog. Hamming-Gewicht, also die Anzahl von nicht erkannten Fehlern, für eine beliebige Anzahl von Bitfehlern ist dabei insbesondere kleiner oder gleich 1 % der Anzahl der möglichen Fehler.
Gemäß einer Ausführungsform wird der (dann) aktuelle Prüfwert in dem sicheren Betriebsmodus bei Eintritt eines vorgegebenen Überprüfungsereignisses überprüft. Zweckmäßigerweise kann auf diese Weise vorgegeben werden, wie oft bzw. zu welchen speziellen Ereignissen der jeweils aktuelle Prüfwert während des sicheren Betriebsmodus überprüft werden soll. Gemäß einer Ausführungsform umfasst das vorgegebene Überprüfungsereignis ein Einlesen eines vorgegebenen Überprüfungsbefehls. Ein derartiger Überprüfungsbefehl kann ein spezieller Maschinenbefehl sein, um die Prozessoreinheit anzuweisen, den jeweils aktuellen Prüfwert zu überprüfen. Ein derartiger Überprüfungsbefehl kann zweckmäßigerweise jederzeit je nach Bedarf oder auf ein spezielles auslösendes Ereignis hin erzeugt werden, z.B. nach einer vorgegebenen Anzahl von eingelesenen Befehlen. Auf diese Weise kann beispielsweise eine vorgegebene Fehlererkennungszeit eingehalten werden und es kann beispielsweise verhindert werden, dass durch zu viele eingelesene, nicht überprüfte Befehle eine Fehlerabdeckung verringert wird, also eine Wahrscheinlichkeit, jede Kombination von Fehlern zu erkennen zu können. Beispielsweise können derartige Überprüfungsbefehle im Zuge des Kompiliervorgang erzeugt und zweckmäßigerweise an geeigneter Stelle in dem Befehlsablauf platziert werden. Der Überprüfungsbefehl kann mit einem Referenzwert angereichert sein.
Alternativ oder zusätzlich umfasst das vorgegebene Überprüfungsereignis gemäß einer Ausführungsform ein Einlesen eines Sprungbefehls zum Ausführen eines Sprungs im Programmablauf. Ein derartiger Sprungbefehl weist die Prozessoreinheit an, zu einem speziellen Befehl des Programmcodes bzw. zu einer entsprechenden Speicheradresse zu springen und diesen bzw. den dortigen Befehl auszuführen. Ein derartiger Sprung kann prinzipiell überall hinführen, auch zu einem potenziell gefährlichen Ziel. Um dies zu verhindern, kann zweckmäßigerweise mit jedem Sprung eine Überprüfung des jeweils aktuellen Prüfwerts durchgeführt werden, im Zuge dessen insbesondere der aus dem Sprungbefehl berechnete Prüfwert selbst überprüft wird.
Alternativ oder zusätzlich umfasst das vorgegebene Überprüfungsereignis gemäß einer Ausführungsform ein Einlesen eines Subroutinenbefehls zum Ausführen einer Subroutine. Durch einen derartigen Subroutinenbefehl kann die Prozessoreinheit ähnlich wie bei einem Sprungbefehl zweckmäßigerweise angewiesen werden spezielle Befehle eines bestimmten Programmcodemoduls auszuführen. Insbesondere wenn diese Subroutine groß ist oder aus einer anderen Quelldatei als die restlichen Befehle kompiliert ist, kann eine Überprüfung durchgeführt werden. Zu diesem Zweck kann insbesondere mit dem Einlesen eines jeweiligen Subroutinenbefehls eine Überprüfung des dann aktuellen Prüfwerts durchgeführt werden.
Alternativ oder zusätzlich umfasst das vorgegebene Überprüfungsereignis ein Einlesen eines Verzweigungsbefehls zum Ausführen von mehreren Zweigen von Befehlen. Durch einen derartigen Verzweigungsbefehl kann die Prozessoreinheit angewiesen werden, einen regulären, linearen Programmablauf aufzuspalten. Zu Beginn jedes dieser Befehlszweige kann zweckmäßigerweise eine Überprüfung des dann aktuellen Prüfwerts durchgeführt werden.
Gemäß einer Ausführungsform wird eine vorgegebene Maßnahme durchgeführt, wenn nach einer vorgegebenen maximalen Anzahl von eingelesenen Befehlen und/oder nach Ablauf eines vorgegebenen maximalen Zeitintervalls keine Überprüfung des jeweils aktuellen Prüfwerts durchgeführt wurde. Wenn beispielsweise nach 100 eingelesenen Befehlen und/oder nach einer Mikrosekunde keine Überprüfung erfolgt ist, kann als Maßnahme beispielsweise eine Fehlermeldung ausgegeben werden, z.B. Timeout-Fehler.
Gemäß einer Ausführungsform wird in dem sicheren Betriebsmodus, insbesondere zum Beenden desselben, ein Deaktivierungsbefehl zum Deaktivieren des sicheren Betriebsmodus eingelesen. Der aktuelle Prüfwert wird dann aus diesem Deaktivierungsbefehl und dem vorherigen Prüfwert berechnet und dieser aktuelle Prüfwert wird überprüft. Somit kann abschließend festgestellt werden, dass der sichere Betriebsmodus fehlerfrei war. Auf Einlesen dieses Deaktivierungsbefehls hin kann der sichere Betriebsmodus durch die Prozessoreinheit deaktiviert werden und die Recheneinheit kann wieder in dem regulären Betriebsmodus betrieben werden. Beispielsweise kann auch dieser Deaktivierungsbefehl, entsprechend dem Aktivierungsbefehl, mittels einer Compiler-Anweisung bzw. Pragma- Direktive realisiert sein.
Gemäß einer Ausführungsform wird nach dem Einlesen des Aktivierungsbefehls ein erster Prüfwert aus einem ersten aktuell auszuführenden Befehl und einem vorbestimmten Initialprüfwert oder einem eingelesenen Initialprüfwert als der vorherige Prüfwert berechnet. In dem sicheren Betriebsmodus erfolgt dann das Überprüfen des jeweiligen aktuellen Prüfwerts ausgehend von diesem ersten Prüfwert. Beispielsweise kann die Prüfwertberechnung mit diesem Anfangswert derart initialisiert werden, dass der Prüfwert, der beim Deaktivieren überprüft wird, in einem fehlerfreien Fall einem vorbestimmten erwarteten Wert entspricht, z.B. dem Wert null. Alternativ kann die Prüfwertberechnung auch mit einem vorgegebenen Anfangswert, z.B. null, initialisiert werden, wobei der Endwert in einem fehlerfreien Fall dann einem Wert entspricht, der in Kenntnis der Befehlskette vorberechnet werden kann.
Gemäß einer Ausführungsform werden vorab vor dem Aktivieren des sicheren Betriebsmodus einzulesende Befehle, beispielsweise einer, mehrere oder alle, jeweils mit einem Referenzprüfwert versehen. Besonders zweckmäßig werden diese Referenzprüfwerte im Zuge eines Kompilierprozesses des Programmcodes in dem ausführbaren Maschinencode erstellt. Zur Ausführung werden die einzulesenden Befehle zusammen mit dem jeweiligen Referenzprüfwert zweckmäßigerweise in die flüchtige Speichereinheit geladen, von welcher die einzelnen Befehle in dem sicheren Betriebsmodus zusammen mit dem Referenzprüfwert eingelesen werden. Die Überprüfung des im Zuge des sicheren Betriebsmodus aus einem jeweiligen eingelesenen Befehl berechneten jeweiligen aktuellen Prüfwerts kann dann abhängig von dem jeweiligen Referenzprüfwert dieses jeweiligen Befehls durchgeführt werden, insbesondere durch Vergleichen des entsprechenden aktuellen Prüfwerts mit dem jeweiligen Referenzprüfwert.
Gemäß einer Ausführungsform wird in dem sicheren Betriebsmodus der aktuelle Prüfwert modifiziert, wenn eine Anzahl von Befehlen übersprungen und nicht ausgeführt wird und/oder wenn eine Anzahl von bereits ausgeführten Befehlen erneut ausgeführt wird, beispielsweise durch Ausführen einen entsprechenden Sprung- oder Verzweigungsbefehls. In einem derartigen Fall kann bei vorgegebenem Auslassen oder Wiederholen einzelner Befehle die Prüfwerteüberprüfung fehlerhaft ausfallen, obwohl sämtliche Befehle korrekt und wie vorgegeben eingelesen und ausgeführt wurden. Um dies zu verhindern, wird der aktuelle Prüfwert mit Hilfe eines Modifizierungsbefehls modifiziert bzw. verändert. Wenn eine Anzahl von Befehlen im Zuge eines Sprungs nicht ausgeführt wird, wird ein erster Modifizierungsbefehl von der Prozessoreinheit eingelesen und ausgeführt. Durch diesen ersten Modifizierungsbefehl, beispielsweise durch ein Argument des ersten Modifizierungsbefehls, wird der aktuelle Prüfwert derart modifiziert, als ob die einzelnen übersprungenen Befehle ausgeführt worden wären. Wenn im Zuge einer Schleife eine Anzahl von bereits ausgeführten Befehlen erneut ausgeführt wird, wird ein zweiter Modifizierungsbefehl eingelesen. Durch diesen zweiten Modifizierungsbefehl bzw. durch ein Argument dieses Befehls wird der jeweils aktuelle Prüfwert derart modifiziert, als ob die einzelnen erneut ausgeführten Befehle nur einmal ausgeführt worden wären. Beispielsweise kann der jeweilige Modifizierungsbefehl im Zuge des Kompilierprozesses erstellt und an zweckmäßiger Stelle in den Befehlsablauf eingebracht werden.
Gemäß einer Ausführungsform weist die Recheneinheit eine Prozessoreinheit auf, die auf einer RISC-V Befehlssatzarchitektur (engl. "Instruction Set Architecture", ISA) basiert. Ein Befehlssatz bezeichnet im Allgemeinen die Gesamtheit von Maschinenbefehlen, die eine Prozessoreinheit ausführen kann. Die RISC-V Befehlssatzarchitektur basiert auf dem sog. RISC-Prinzip (engl. "Reduced Instruction Set Computer", RISC), gemäß welchem der Befehlssatz eine geringe Anzahl von Befehlen umfasst, üblicherweise unter 100, welche von der Prozessoreinheit jeweils einfach und schnell abgearbeitet werden können, wodurch ein vereinfachtes Prozessordesign, eine hohe Prozessortaktung und eine schnelle Ausführungsgeschwindigkeit erreicht werden kann, im Gegensatz zu der sog. CISC-Architektur (englisch "Complex Instruction Set Computing", CISC), welche einen Befehlssatz mit einer hoher Anzahl von Befehlen (über 100) bereitstellt, durch welche ein jeweiliger Prozessor komplexe Prozesse ausführen kann, was jedoch mit einem komplexen Prozessordesign verbunden ist. Die RISC-V Befehlssatzarchitektur ist ein offener Standard bzw. "Open Source" und ermöglicht es auf einfache Weise, Änderungen und Erweiterungen an dem Befehlssatz vorzunehmen. RISC-V Prozessoren bzw. im Allgemeinen Prozessoren mit einer modifizierbaren Befehlssatzarchitektur eignen sich daher besonders zweckmäßig für die Implementierung des sicheren Betriebsmodus, da sich für die Ausführung des sicheren Betriebsmodus benötigte Befehle, beispielsweise die Aktivierungs-, De- aktivierungs-, Überprüfungs- oder Modifizierungsbefehle, auf einfache Weise in den Befehlssatz integrieren lassen. Besonders bevorzugt eignet sich das Verfahren zur Anwendung im Fahrzeugbereich. Die Recheneinheit kann insbesondere als ein Mikrocontroller oder Steuergerät in einem (Kraft-) Fahrzeug ausgebildet sein. Von der Recheneinheit ausgeführte Prozesse können beispielsweise sicherheitskritische Funktionen umfassen, welche zum sicheren Betrieb und zur Steuerung des Fahrzeugs ausgeführt werden, beispielsweise im Zuge einer Motorsteuerung, im Zuge von Fahrassistenzfunktionen oder auch in Zuge des autonomen Fahrens usw. Sicherheit bzw. Ausfallsicherheit und Integrität des Steuergeräts können durch das vorliegende Verfahren erhöht werden. Insbesondere können durch das Verfahren Sicherheitsanforderungen im (Kraft-) Fahrzeugbereich erfüllt werden, wie sie beispielsweise in der Norm ISO 26262 oder insbesondere von dem sog. "Automotive Safety Integrity Level" (ASIL), eine von der ISO 26262 spezifizierte Sicherheitsanforderungsstufe für sicherheitsrelevante Systeme in Kraftfahrzeugen, vorgegeben werden.
Eine erfindungsgemäße Recheneinheit, z.B. ein Steuergerät eines Kraftfahrzeugs, ist, insbesondere programmtechnisch, dazu eingerichtet, ein erfindungsgemäßes Verfahren durchzuführen.
Auch die Implementierung eines erfindungsgemäßen Verfahrens in Form eines Computerprogramms oder Computerprogrammprodukts mit Programmcode zur Durchführung aller Verfahrensschritte ist vorteilhaft, da dies besonders geringe Kosten verursacht, insbesondere wenn ein ausführendes Steuergerät noch für weitere Aufgaben genutzt wird und daher ohnehin vorhanden ist. Schließlich ist ein maschinenlesbares Speichermedium vorgesehen mit einem darauf gespeicherten Computerprogramm wie oben beschrieben. Geeignete Speichermedien bzw. Datenträger zur Bereitstellung des Computerprogramms sind insbesondere magnetische, optische und elektrische Speicher, wie z.B. Festplatten, Flash- Speicher, EEPROMs, DVDs u.a.m. Auch ein Download eines Programms über Computernetze (Internet, Intranet usw.) ist möglich. Ein solcher Download kann dabei drahtgebunden bzw. kabelgebunden oder drahtlos (z.B. über ein WLAN- Netz, eine 3G-, 4G-, 5G- oder 6G-Verbindung, etc.) erfolgen. Weitere Vorteile und Ausgestaltungen der Erfindung ergeben sich aus der Beschreibung und der beiliegenden Zeichnung.
Die Erfindung ist anhand von Ausführungsbeispielen in der Zeichnung schematisch dargestellt und wird im Folgenden unter Bezugnahme auf die Zeichnung beschrieben.
Kurze Beschreibung der Zeichnungen
Figur 1 zeigt schematisch eine Ausgestaltung einer erfindungsgemäßen Recheneinheit, die dazu eingerichtet ist, eine Ausführungsform eines erfindungsgemäßen Verfahrens durchzuführen.
Figur 2 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 3 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 4 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 5 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 6 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 7 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm.
Figur 8 zeigt schematisch eine Ausführungsform eines erfindungsgemäßen Verfahrens als ein Blockdiagramm. Ausführungsform(en) der Erfindung
In Figur 1 ist eine Recheneinheit schematisch dargestellt und mit 100 bezeichnet, die beispielsweise als ein System-on-a-Chip (SoC) ausgebildet sein kann. Beispielsweise kann das SoC 100 für ein Kraftfahrzeug vorgesehen sein und in ein Steuergerät des Fahrzeugs integriert sein, beispielsweise um sicherheitskritische Funktionen für den sicheren Betrieb des Fahrzeugs auszuführen, z.B. im Zuge einer Motorsteuerung, im Zuge von Fahrassistenzfunktionen, in Zuge des autonomen Fahrens usw.
Um Sicherheit und Integrität des Steuergeräts gewährleisten, um Software auf höchstem Sicherheitsniveau ausführen und um Sicherheitsanforderungen des (Kraft-) Fahrzeugbereichs erfüllen zu können, insbesondere gemäß der ASIL-D Sicherheitsanforderungsstufe der Norm ISO 26262, ist das SoC 100, insbesondere programmtechnisch, dazu eingerichtet, eine Ausführungsform eines erfindungsgemäßen Verfahrens durchzuführen. Im Zuge dieses Verfahrens kann das SoC 100 in einem sicheren Betriebsmodus betrieben werden, in welchem ein sicherer Abruf von Befehlen ermöglicht wird. Auf diese Weise wird eine funktionssichere Ausführungsplattform 110 ("Safe Island", "Vital Modules", "Safe Backbone" oder "Safe Execution Platform") in dem SoC 100 realisiert.
Für diese funktionssichere Ausführungsplattform 110 bzw. zum Ausführen des sicheren Betriebsmodus sind im gezeigten Beispiel eine Prozessoreinheit 111 , eine Cache-Logikeinheit 112 und ein Zeitgeber 113 vorgesehen. Die Prozessoreinheit 111 kann zweckmäßigerweise (aber nicht beschränkend) ein Prozessorkern sein, der auf einer RISC-V-Befehlssatzarchitektur basiert. Dieser RISC-V- Prozessor 111 und die Cache-Logikeinheit 113 sind beispielsweise über RAM- und Cache-Speicher 121 an eine Verbindungseinheit (engl. "Interconnect") 120 des SoC 100 als weitere Elemente der funktionssicheren Ausführungsplattform 110 angebunden. Beispielsweise kann eine Flash-Speichereinheit 140, z.B. ein NAND-Flash-Speicher, über eine Schnittstelle 141 an die Verbindungseinheit 120 angebunden sein und eine RAM-Speichereinheit 150, z.B. ein LPDDR-RAM, über einen RAM-Controller 151. Das SoC 100 kann ferner einen oder mehrere weitere Prozessorkerne 130 mit zugehörigem RAM- und Cache-Speicher 131 aufweisen, welche an die Verbindungseinheit 120 angebunden sind. Ferner können eine Speichereinheit 122 als weiteres Element der funktionssicheren Ausführungsplattform 110 für einen Startprozess (Boot-Flash-Speicher) sowie ein peripherer Bus 160 an die Verbindungseinheit 120 angebunden sein. An den peripheren Bus 160 kann eine Vielzahl von Peripherieeinheiten angebunden sein, z.B. ein Analog-Digital-Wandler 161 , ein serielles Bussystem 162 ("Serial Peripheral Interface", SPI), eine Einheit für direkte Speicherzugriffe 163 ("Direct Memory Access", DMA), ein Zeitgeber 164 und ein weiteres Feldbussystem 165, z.B. ein Flexray-Feldbus. Es versteht sich, dass auch weniger oder noch weitere Peripherieeinheiten vorgesehen sein können, angedeutet durch Bezugszeichen 166. Über das serielles Bussystem 162 kann beispielsweise eine externe Über- wachungseinheit 180 zum Erkennen und Verwalten eines Fehlers oder eines Ausfalls des SoC 100 (engl. "Watchdog") angebunden sein. Ferner kann das SoC 100 eine Fehlerverwaltungseinheit 170 (engl. "Error Management Modul", EMM) zur Verwaltung von ausgegebenen Fehlermeldungen aufweisen.
In dem sicheren Betriebsmodus erfolgt durch den Prozessor 111 eine Berechnung und Überprüfung von Prüfwerten eingelesener Befehle, um eine Integrität der Befehle von einem Compiler bis zu dem Prozessorkern 111 zu gewährleisten, wie nachfolgend in Bezug auf die Figuren 2 bis 8 erläutert werden soll.
In den Figuren 2 bis 8 ist jeweils eine Ausführungsform des erfindungsgemäßen Verfahrens schematisch als ein Blockdiagramm dargestellt. Die einzelnen Figuren 2 bis 8 zeigen jeweils eine Abfolge von Befehlen, welche von dem Prozessor 111 eingelesen und ausgeführt werden können.
Diese einzelnen Befehle werden beispielsweise im Zuge eines Kompilierprozesses eines Programmcodes durch einen Compiler erzeugt, wobei jeweils ein Referenzprüfwert jedes erzeugten Befehls berechnet wird. Diese Befehle können zusammen mit dem jeweiligen Referenzprüfwert beispielsweise in der Flash-Speichereinheit 140 hinterlegt werden und von dort aus während des Betriebs des SoC 100 in die RAM-Speichereinheit 150 kopiert werden. Insbesondere wird wenigstens einer der Befehle, zweckmäßigerweise der erste oder der letzte der sicher auszuführenden, zusammen mit dem Referenzprüfwert hinterlegt, beispielsweise als Argument des Befehls. Vorzugsweise werden jedoch mehrere oder alle Befehle jeweils mit ihrem Referenzprüfwert hinterlegt. Aus dem RAM- Speicher 150 können die einzelnen Befehle zusammen mit dem jeweiligen Referenzprüfwert durch den Prozessor 111 jeweils im Zuge eines Befehlsabrufs ("fetch", "instruction fetch") eingelesen und ausgeführt werden.
Wie in Figur 2 dargestellt, werden im Zuge eines regulären Betriebsmodus Befehle 202, 204 und 206 von dem Prozessor 111 auf reguläre Weise eingelesen und ausgeführt. Während dieses regulären Betriebsmodus wird kein Prüfwert der eingelesenen Befehle berechnet. Wenn ein Aktivierungsbefehl 208 eingelesen wird, aktiviert der Prozessor 111 den sicheren Betriebsmodus. Fortan wird bis zum Deaktivieren des sicheren Betriebsmodus von dem Prozessor 111 jeweils ein aktueller Prüfwert aus jedem eingelesenen Befehl und dem vorherigen Prüfwert berechnet.
Nach dem Einlesen des Aktivierungsbefehls 208 wird ein erster Prüfwert insbesondere aus einem ersten aktuell auszuführenden Befehl und einem vorbestimmten Initialprüfwert oder einem eingelesenen Initialprüfwert als der vorherige Prüfwert berechnet. Beispielsweise kann die Prüfwertberechnung mit einem eingelesenen Initialprüfwert derart initialisiert werden, dass ein später zu berechnender Endwert in einem fehlerfreien Fall einem vorgegebenen Wert entsprechen sollte, z.B. null.
Nach dem Aktivieren des sicheren Betriebsmodus liest der Prozessor 111 einen Befehl 210 ein und berechnet den aktuellen Prüfwert aus diesem Befehl 210 und aus dem Initialprüfwert. Der Prozessor 111 liest dann den nächsten Befehl 212 ein und berechnet den aktuellen Prüfwert aus diesem Befehl 212 und aus dem vorherigen Prüfwert.
Bei diesem Befehl 212 handelt es sich beispielsweise um einen Subroutinenbefehl zum Ausführen einer Subroutine. Der Prozessor 111 führt die entsprechende Subroutine bzw. ein entsprechendes Programmcodemodul aus. Im Zuge dessen liest der Prozessor 111 die Befehle 218, 220, 222, 224, 226, 228, 230 und 232 ein und berechnet jeweils den aktuellen der Prüfwert aus dem jeweils eingelesenen Befehl und dem jeweiligen vorherigen Prüfwert. Bei dem Befehl 232 kann es sich beispielsweise um einen Rückkehrbefehl handeln, welcher das Ende der Subroutine charakterisiert und den Prozessor 111 anweist, zu dem vorherigen Befehlsablauf zurückzukehren.
Auf den Rückkehrbefehl 232 hin liest der Prozessor 111 die Befehle 214 und 216 ein und berechnet den jeweils aktuellen Prüfwert. Der Befehl 216 kann beispielsweise ein Sprungbefehl sein, um zu einem speziellen Befehl 234 bzw. zu dessen Speicheradresse in dem RAM 150 zu springen. Daraufhin liest der Prozessor 111 diesen Befehl 234 ein berechnet den aktuellen Prüfwert. Bei dem nächsten eingelesenen Befehl 236 kann es sich beispielsweis erneut um einen Subroutinenbefehl handeln. Auf Einlesen dieses Subroutinenbefehls 236 hin liest der Prozessor 111 erneut die einzelnen Befehle 218, 220, 222, 224, 226, 228, 230 und 232 dieses Moduls ein und berechnet jeweils den aktuellen Prüfwert.
Auf erneutes Einlesen des Rückkehrbefehls 232 hin kehrt der Prozessor 111 zu den vorherigen Befehlsablauf zurück und liest die Befehle 238 und 240 ein und berechnet jeweils den aktuellen Prüfwert.
Der Befehl 240 ist beispielsweise ein Deaktivierungsbefehl zum Deaktivieren des sicheren Betriebsmodus. Auf diesen eingelesenen Deaktivierungsbefehl 240 hin deaktiviert der Prozessor 111 den sicheren Betriebsmodus. Ferner führt der Prozessor 111 auf Einlesen des Deaktivierungsbefehls 240 hin eine Überprüfung des aktuellen Prüfwerts durch. Im Zuge dessen wird überprüft, ob der aus dem Deaktivierungsbefehl 240 berechnete aktuelle Prüfwert als Endwert z.B. dem vorgegebenen Wert null entspricht.
Wenn dieser Endwert nicht dem Wert null entspricht, deutet dies auf einen Fehler hin und es wird eine vorgegebene Maßnahme durchgeführt, z.B. eine Fehlermeldung ausgegeben oder das System angehalten oder in einen sicheren Zustand gebracht. Wenn der Endwert hingegen dem Wert null entspricht, deutet dies darauf hin, dass kein Fehler vorliegt. Der Prozessor 111 kehrt dann zu dem regulären Betriebsmodus zurück. Im Zuge dessen liest der Prozessor 111 die Befehle 242 und 244 ein, ohne einen Prüfwert zu berechnen. Gemäß einer Ausführungsform kann auch eine Überprüfung des jeweils aktuellen Prüfwerts während des sicheren Betriebsmodus durchgeführt werden, wie nachfolgend in Bezug auf Figur 3 erläutert wird. Beispielsweise wenn die Subroutine groß ist oder aus einer anderen Quelldatei als die restlichen Befehle kompiliert ist, kann eine Überprüfung des Prüfwerts mit dem Starten dieser Subroutine während des sicheren Betriebsmodus zweckmäßig sein.
Wie in Figur 3 gezeigt, liest der Prozessor 111 im Zuge des regulären Betriebsmodus die Befehle 302, 304 und 306 ein, ohne einen Prüfwert zu berechnen. Der nächste eingelesene Befehl 308 ist beispielsweise der Aktivierungsbefehl, woraufhin der sichere Betriebsmodus aktiviert wird. Wie obig erläutert, berechnet der Prozessor 111 von nun an den jeweils aktuellen Prüfwert aus jedem eingelesenen Befehl und initialisiert die Prüfwertberechnung auf den Aktivierungsbefehl 306 hin mit einem Initialprüfwert.
In dem sicheren Betriebsmodus liest der Prozessor 111 zunächst den Befehl 310 und daraufhin den Subroutinenbefehl 312 ein, woraufhin die Subroutine ausgeführt wird. In dieser Subroutine liest der Prozessor 111 zunächst einen Überprüfungsbefehl 320 ein, woraufhin der Prozessor 111 eine Überprüfung des gerade aktuellen Prüfwerts durchführt. Auf diese Weise kann der eingelesene Subroutinenbefehl 312 insbesondere unmittelbar nach dessen Ausführung überprüft werden. Für diese Überprüfung vergleicht der Prozessor 111 den aus dem Subroutinenbefehl 312 berechneten Prüfwert z.B. mit dem vorgegebenen Wert null.
Nach diesem Überprüfen liest der Prozessor 111 den nächsten Befehl 322 ein und berechnet den aktuellen Prüfwert aus diesem Befehl 322 und dem vorherigen Prüfwert (hier Null).
Daraufhin liest der Prozessor 111 die Befehle 324, 326, 328, 330, 332 und 334 der Subroutine ein und berechnet jeweils den aktuellen Prüfwert. Der Befehl 334 ist beispielsweise ein Rückkehrbefehl, woraufhin der Prozessor 111 zu dem vorherigen Befehlsablauf zurückzukehrt und den Befehl 314 ausführt. Auch dieser Befehl 314 ist beispielsweise ein Überprüfungsbefehl, woraufhin der Prozessor 111 erneut eine Überprüfung des aktuellen Prüfwerts durchführt. Auf diese Weise kann die Subroutine bzw. deren einzelne Befehle insbesondere unmittelbar nach deren Ausführung überprüft werden. Auch auf diese Überprüfung hin initialisiert der Prozessor die Prüfwertberechnung mit dem Einlesen des nächsten Befehls 316 mit einem neuen Initialprüfwert neu.
Daraufhin liest der Prozessor 111 den Befehl 318 ein, wobei dieser Befehl 318 beispielsweise ein Sprungbefehl ist, woraufhin der Prozessor 111 zu dem Befehl 336 springt und diesen einliest. Der Prozessor 111 liest dann den Befehl 338 ein, welcher beispielsweise erneut ein Subroutinenbefehl ist. Der Prozessor 111 liest nun erneut den Befehl 320 ein, führt eine Überprüfung des aktuellen Prüfwerts durch, und initialisiert die Prüfwertberechnung mit dem Befehl 322 neu. Daraufhin liest der Prozessor 111 erneut die weiteren Befehle 324, 326, 328, 330, 332 und 334 der Subroutine ein, kehrt auf den Rückkehrbefehl 334 zu dem vorherigen Befehlsablauf zurück und liest den Befehl 340 ein. Auch dieser Befehl 340 ist ein Überprüfungsbefehl, auf welchen der Prozessor 111 eine Überprüfung des aktuellen Prüfwerts durchführt.
Der Prozessor 111 liest dann die Befehle 342, 344 und 346 ein, wobei der Befehl 346 der Deaktivierungsbefehl ist und der sichere Betriebsmodus deaktiviert wird. Auch auf den Deaktivierungsbefehl 346 hin führt der Prozessor 111 eine Überprüfung des aktuellen Prüfwerts durch. Der Prozessor 111 kehrt dann zu dem regulären Betriebsmodus zurück und liest die Befehle 348 und 350 ein, ohne einen Prüfwert zu berechnen.
Gemäß einer Ausführungsform kann eine Überprüfung des aktuellen Prüfwerts auch auf einen Sprungbefehl hin durchgeführt werden, wie nachfolgend in Bezug auf Figur 4 erläutert wird. Da Sprungbefehle prinzipiell auch zu einem potenziell gefährlichen Ziel führen können, kann es zweckmäßig sein, mit einem Sprung eine Überprüfung durchzuführen.
Im Beispiel von Figur 4 befindet sich der Prozessor 111 bereits in dem sicheren Betriebsmodus und liest im Zuge dessen die Befehle 402, 404, 406 und 408 ein und berechnet jeweils den aktuellen Prüfwert. Bei dem Befehl 408 handelt es sich beispielsweise um einen Sprungbefehl, um einen indirekten Sprung zu mehreren Adressen bzw. zu mehreren weiteren Befehlen 410, 416 und 424 durchzuführen.
Der Prozessor 111 liest dann diese Befehle 410, 416 und 424 jeweils ein und berechnet jeweils den aktuellen Prüfwert. Insbesondere ist jeder dieser Befehle 410, 416 und 424 jeweils ein Überprüfungsbefehl, woraufhin der Prozessor 111 jeweils eine Überprüfung des jeweiligen aktuellen Prüfwerts durchführt. Auf diese Weise kann der eingelesene Sprungbefehle 408 unmittelbar nach dessen Ausführung überprüft werden. Nach der jeweiligen Überprüfung liest der Prozessor 111 die einzelnen Befehle 412, 414, 418, 420, 422, 426, 428 und 430 ein und berechnet jeweils den aktuellen Prüfwert.
Beispielsweise kann der Befehl 408 auch ein Subroutinenbefehl sein, um im Zuge eines indirekten Funktionsaufrufs mehrere Subroutinen auszuführen. In diesem Fall charakterisieren die Befehle 410, 412 und 414 eine erste Subroutine, die Befehle 416, 418, 420 und 422 eine zweite Subroutine und die Befehle 424, 426, 428 und 430 eine dritte Subroutine. Ferner kann es sich in diesem Fall bei den jeweiligen letzten Befehle 414, 422 und 430 der einzelnen Subroutinen jeweils um einen Rückkehrbefehl handeln.
Gemäß einer Ausführungsform kann eine Überprüfung des aktuellen Prüfwerts auch auf einen Verzweigungsbefehl zum Ausführen von mehreren Zweigen von Befehlen hin durchgeführt werden, wie nachfolgend in Bezug auf Figur 5 erläutert wird.
Auch im Beispiel von Figur 5 befindet sich der Prozessor 111 bereits in dem sicheren Betriebsmodus, im Zuge dessen der Prozessor 111 die Befehle 502, 504 und 506 einliest und jeweils den aktuellen Prüfwert berechnet. Bei dem Befehl 506 handelt es sich beispielsweise um einen Verzweigungsbefehl (z.B. If - then), um als einen ersten Zweig die Befehle 508, 510, 512, 514 und 516 einzulesen und auszuführen und um als einen zweiten Zweig die Befehle 520, 522, 524, 526, 528, 530 und 532 einzulesen und auszuführen. Der Prozessor 111 liest daraufhin jeweils den jeweiligen ersten Befehl 508 bzw. 518 dieser beiden Zweige ein, wobei es sich bei diesen Befehlen 508 bzw. 518 jeweils um einen Überprüfungsbefehl handelt, woraufhin der Prozessor 111 jeweils eine Überprüfung des jeweils aktuellen Prüfwerts durchführt. Der Prozessor 111 liest dann jeweils die restlichen Befehle der beiden Zweige ein.
Bei dem jeweiligen letzten Befehl 516 bzw. 532 der beiden Zweige handelt es sich beispielsweise jeweils um einen Sprungbefehl um zu dem Befehl 534 zu springen. Die beiden Zweige vereinen sich somit wieder und der Prozessor 111 liest diesen Befehl 534 sowie die nachfolgenden Befehle 536 und 538 ein.
Mit Hilfe von Sprung- oder Verzweigungsbefehlen können ferner auch Befehle in der Behelfsabfolge übersprungen oder im Zuge einer Schleife erneut ausgeführt werden, wie nachfolgend in Bezug auf die Figuren 6a und 6b erläutert wird.
Im Beispiel von Figur 6a befindet sich der Prozessor 111 bereits in dem sicheren Betriebsmodus und liest die Befehle 602, 604 und 606 ein und berechnet jeweils den aktuellen Prüfwert. Der Befehl 606 ist ein Sprungbefehl, um die Befehle 608, 610 und 612 nicht auszuführen und zu dem Befehl 614 zu springen. Beispielsweise kann es sich bei dem zu überspringenden Befehl 608 um einen Überprüfungsbefehl handeln.
Auf das Einlesen des Sprungbefehls 606 hin liest der Prozessor 111 den Befehl 614 ein, welcher beispielsweise ein Überprüfungsbefehl ist, und führt die entsprechende Überprüfung durch. Der Prozessor fährt dann mit dem Befehlsablauf fort und liest den Befehl 616 ein.
Auch im Beispiel von Figur 6b befindet sich der Prozessor 111 in dem sicheren Betriebsmodus, liest die Befehle 650, 652, 654, 656, 658, 660, 662, 664 und 666 ein und berechnet jeweils den aktuellen Prüfwert. Bei den Befehlen 652 und 660 handelt es sich jeweils beispielsweise um einen Überprüfungsbefehl. Der Befehl 666 ist ein Sprungbefehl, um zu dem Überprüfungsbefehl 660 zurückzukehren und um erneut die Befehle 660, 662 und 664 einzulesen. Nach diesem erneuten Einlesen liest der Prozessor 111 die Befehle 668, 670, 672, 674 und 676 ein. Der Befehl 668 ist beispielsweise ebenfalls ein Überprüfungsbefehl. Der Befehl 676 ist beispielsweise ein Sprungbefehl, um zu dem Überprüfungsbefehl 652 zurückzukehren und um erneut die Befehle 652 bis 674 einzulesen. Der Prozessor 111 fährt anschließend mit den Befehle 678, 680 und 682 fort, wobei auch der Befehl 678 ein Überprüfungsbefehl ist.
Gemäß einer Ausführungsform kann in derartigen Fällen bei Auslassen oder Wiederholen einzelner Befehle der aktuelle Prüfwert auch mit Hilfe eines Modifizierungsbefehls modifiziert werden, wie nachfolgend in Bezug auf die Figuren 7a und 7b erläutert wird.
Im Beispiel von Figur 7a befindet sich der Prozessor 111 in dem sicheren Betriebsmodus, liest die Befehle 702, 704, 706, 708 und 710 ein und berechnet jeweils den aktuellen Prüfwert, wobei der Befehl 710 ein Sprungbefehl ist, um die Befehle 712, 714 und 716 nicht auszuführen und zu dem Befehl 718 zu springen. Der Befehl 704 ist ein erster Modifizierungsbefehl, durch welchen der aktuelle Prüfwert derart modifiziert wird, als ob die einzelnen nicht ausgeführten Befehle 712, 714 und 716 dennoch ausgeführt worden wären.
Auch im Beispiel von Figur 7b befindet sich der Prozessor 111 in dem sicheren Betriebsmodus und liest die Befehle 750, 752, 754, 756, 758, 760, 762, 764 und 766 ein und berechnet jeweils den aktuellen Prüfwert. Der Befehl 766 ist ein Sprungbefehl, um zu dem Befehl 760 zurückzukehren und um erneut die Befehle 760, 762 und 764 einzulesen. Der Befehl 758 ist ein zweiter Modifizierungsbefehl, durch welchen der jeweils aktuelle Prüfwert derart modifiziert wird, als ob die einzelnen erneut ausgeführten Befehle 760, 762 und 764 nur einmal ausgeführt worden wären.
Nach dem erneuten Einlesen der Befehle 760, 762 und 764 liest der Prozessor 111 die Befehle 768, 770, 772, 774 und 776 ein. Auch der Befehl 776 ist ein Sprungbefehl, um zu dem Befehl 752 zurückzukehren und um erneut die Befehle 752 bis 774 einzulesen. Auch der Befehl 770 ist ein zweiter Modifizierungsbefehl, durch welchen der aktuelle Prüfwert derart modifiziert wird, als ob die einzelnen erneut ausgeführten Befehle 752 bis 774 nur einmal ausgeführt worden wären. Nach dem erneuten Einlesen dieser Befehle 752 bis 774 fährt der Prozessor 111 mit dem Einlesen der nächsten Befühlte 778, 780 und 782 fort. Beispielsweise ist der Befehl 780 ebenfalls ein zweiter Modifizierungsbefehl, um den aktuellen Prüfwert für einen nachfolgenden Sprungbefehl zu modifizieren.
Durch Verwendung derartiger erster und zweiter Modifizierungsbefehle kann die Anzahl von Überprüfungsbefehlen im Vergleich zu den Figuren 6a und 6b reduziert werden. Es ist auch denkbar, eine Kombination von Modifizierungs- und Überprüfungsbefehlen zu verwenden, wie nachfolgend in Bezug auf Figur 8 erläutert wird.
Im Beispiel von Figur 8a befindet sich der Prozessor 111 in dem sicheren Betriebsmodus, liest die Befehle 802, 804, 806, 808 und 810 ein und berechnet jeweils den aktuellen Prüfwert, wobei der Befehl 810 ein Sprungbefehl ist, um die Befehle 812, 814 und 816 nicht auszuführen und zu dem Befehl 818 zu springen. Der Befehl 804 ist ein Modifizierungsbefehl, durch welchen der aktuelle Prüfwert jedoch für den unmittelbar nächsten Sprungbefehl 810 nicht modifiziert wird. Die Befehle 812 und 818 können jeweils ein Überprüfungsbefehl sein.
Auch im Beispiel von Figur 8b befindet sich der Prozessor 111 in dem sicheren Betriebsmodus und liest die Befehle 850, 852, 854, 856, 858, 860, 862, 864 und 866 ein und berechnet jeweils den aktuellen Prüfwert. Der Befehl 866 ist ein Sprungbefehl, um zu dem Befehl 860 zurückzukehren und um erneut die Befehle 860, 862 und 864 einzulesen. Der Befehl 852 ist beispielsweise ein Überprüfungsbefehl. Der Befehl 858 ist ein zweiter Modifizierungsbefehl, durch welchen der aktuelle Prüfwert derart modifiziert wird, als ob die erneut ausgeführten Befehle 860, 862 und 864 nur einmal ausgeführt worden wären.
Der Prozessor 111 liest nach dem erneuten Einlesen der Befehle 860, 862 und 864 die Befehle 868, 870, 872, 874 und 876 ein, wobei der Befehl 876 ein Sprungbefehl ist, um zu dem Überprüfungsbefehl 852 zurückzukehren. Der Prozessor 111 liest nun erneut die Befehle 852 bis 874 ein und fährt anschließend mit den Befehlen 878, 880 und 882 fort.

Claims

Ansprüche
1. Verfahren zum Betreiben einer Recheneinheit (100) in einem sicheren Betriebsmodus, umfassend:
Einlesen eines Aktivierungsbefehls (208, 308) zum Aktivieren eines sicheren Betriebsmodus und Aktivieren des sicheren Betriebsmodus auf den eingelesenen Aktivierungsbefehl hin; in dem sicheren Betriebsmodus, Einlesen von Befehlen und Berechnen jeweils eines aktuellen Prüfwerts aus einem aktuell auszuführenden Befehl und einem vorherigen Prüfwert; in dem sicheren Betriebsmodus, wenigstens einmal Überprüfen des aktuellen Prüfwerts.
2. Verfahren nach Anspruch 1 , weiterhin umfassend: in dem sicheren Betriebsmodus, Überprüfen des aktuellen Prüfwerts bei Eintritt eines vorgegebenen Überprüfungsereignisses.
3. Verfahren nach Anspruch 2, wobei das vorgegebene Überprüfungsereignis eines oder mehrere der nachfolgenden Überprüfungsereignisse umfasst: Einlesen eines vorgegebenen Überprüfungsbefehls (314, 320, 340); Einlesen eines Sprungbefehls (318) zum Ausführen eines Sprungs;
Einlesen eines Subroutinenbefehls (312, 338) zum Ausführen einer Subroutine;
Einlesen eines Verzweigungsbefehls (408) zum Ausführen von mehreren Zweigen von Befehlen.
4. Verfahren nach einem der vorstehenden Ansprüche, wobei eine vorgegebene Maßnahme durchgeführt wird, wenn nach einer vorgegebenen maximalen Anzahl von eingelesenen Befehlen und/oder nach Ablauf eines vorgegebenen maximalen Zeitintervalls keine Überprüfung des aktuellen Prüfwerts durchgeführt wurde.
5. Verfahren nach einem der vorstehenden Ansprüche, ferner umfassend: in dem sicheren Betriebsmodus, Einlesen eines Deaktivierungsbefehls (240, 346) zum Deaktivieren des sicheren Betriebsmodus;
Berechnen des aktuellen Prüfwerts aus dem Deaktivierungsbefehl und dem vorherigen Prüfwert;
Überprüfen des aktuellen Prüfwerts.
6. Verfahren nach einem der vorstehenden Ansprüche, ferner umfassend: nach dem Einlesen des Aktivierungsbefehls, Berechnen eines ersten Prüfwerts aus einem ersten aktuell auszuführenden Befehl und einem vorbestimmten Initialprüfwert oder einem eingelesenen Initialprüfwert als der vorherige Prüfwert.
7. Verfahren nach einem der vorstehenden Ansprüche, ferner umfassend, vor dem Aktivieren des sicheren Betriebsmodus:
Versehen von einzulesenden Befehlen jeweils mit einem Referenzprüfwert.
8. Verfahren nach einem der vorstehenden Ansprüche, ferner umfassend: in dem sichereren Betriebsmodus, wenn eine Anzahl von Befehlen (712, 714, 716) nicht ausgeführt wird, Einlesen eines ersten Modifizierungsbefehls (704) und Modifizieren des jeweils aktuellen Prüfwerts derart, als ob die einzelnen nicht ausgeführten Befehle (712, 714, 716) ausgeführt worden wären; und/oder in dem sichereren Betriebsmodus, wenn eine Anzahl von bereits ausgeführten Befehlen (752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776) erneut ausgeführt wird, Einlesen eines zweiten Modifizierungsbefehls (758, 770, 780) und Modifizieren des jeweils aktuellen Prüfwerts derart, als ob die einzelnen erneut ausgeführten Befehle (752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776) nur einmal ausgeführt worden wären.
9. Recheneinheit (100), die dazu eingerichtet ist, alle Verfahrensschritte eines Verfahrens nach einem der vorstehenden Ansprüche durchzuführen.
10. Recheneinheit (100) nach Anspruch 9, die eine Prozessoreinheit (111) aufweist, die auf einer RISC-V-Befehlssatzarchitektur basiert.
11. Computerprogramm, das eine Recheneinheit (100) dazu veranlasst, alle Verfahrensschritte eines Verfahrens nach einem der Ansprüche 1 bis 8 durchzuführen, wenn es auf der Recheneinheit (100) ausgeführt wird.
12. Maschinenlesbares Speichermedium mit einem darauf gespeicherten Computerprogramm nach Anspruch 11.
EP24716742.2A 2023-04-06 2024-04-02 Verfahren zum betreiben einer recheneinheit in einem sicheren betriebsmodus Pending EP4689899A1 (de)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102023203238.4A DE102023203238A1 (de) 2023-04-06 2023-04-06 Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus
PCT/EP2024/058838 WO2024208780A1 (de) 2023-04-06 2024-04-02 Verfahren zum betreiben einer recheneinheit in einem sicheren betriebsmodus

Publications (1)

Publication Number Publication Date
EP4689899A1 true EP4689899A1 (de) 2026-02-11

Family

ID=90718750

Family Applications (1)

Application Number Title Priority Date Filing Date
EP24716742.2A Pending EP4689899A1 (de) 2023-04-06 2024-04-02 Verfahren zum betreiben einer recheneinheit in einem sicheren betriebsmodus

Country Status (6)

Country Link
US (1) US20260044606A1 (de)
EP (1) EP4689899A1 (de)
JP (1) JP2026513886A (de)
CN (1) CN120898197A (de)
DE (1) DE102023203238A1 (de)
WO (1) WO2024208780A1 (de)

Family Cites Families (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5974529A (en) * 1998-05-12 1999-10-26 Mcdonnell Douglas Corp. Systems and methods for control flow error detection in reduced instruction set computer processors

Also Published As

Publication number Publication date
CN120898197A (zh) 2025-11-04
US20260044606A1 (en) 2026-02-12
WO2024208780A1 (de) 2024-10-10
JP2026513886A (ja) 2026-05-01
DE102023203238A1 (de) 2024-10-10

Similar Documents

Publication Publication Date Title
EP1917592B1 (de) Rechnersystems mit wenigstens zwei ausführungseinheiten und einer vergleichseinheit sowie verfahren zu dessen steuerung
DE102011054204A1 (de) Elektronische Fahrzeugsteuervorrichtung
WO2006015945A2 (de) Verfahren, betriebssystem und rechengerät zum abarbeiten eines computerprogramms
WO2004064075A1 (de) Verfahren zur erkennung und/oder korrektur von speicherzugriffsfehlern und elektronische schaltungsanordnung zur durchführung des verfahrens
DE102013021231A1 (de) Verfahren zum Betrieb eines Assistenzsystems eines Fahrzeugs und Fahrzeugsteuergerät
EP1810139B1 (de) Verfahren, betriebssystem und rechengerät zum abarbeiten eines computerprogramms
DE102023203238A1 (de) Verfahren zum Betreiben einer Recheneinheit in einem sicheren Betriebsmodus
EP1359485B1 (de) Steuer- und Überwachungssystem
DE102005040916A1 (de) Speicheranordnung und Betriebsverfahren dafür
DE102005054587A1 (de) Programmgesteuerte Einheit und Verfahren zum Betreiben derselbigen
DE102013202961A1 (de) Verfahren zum Überwachen eines Stackspeichers in einem Betriebssystem eines Steuergeräts eines Kraftfahrzeuges
DE102023206140B4 (de) Verfahren zum Zugreifen auf einen in einer Speichereinheit einer Recheneinheit hinterlegten Datenblock einer Anzahl von Datenblöcken
WO2004070487A2 (de) Verfahren und vorrichtung zur überwachung einer elektronischen steuerung
EP1812853B1 (de) Verfahren, betriebssystem und rechengerät zum abarbeiten eines computerprogramms
EP2090952A2 (de) Hydraulikkomponenten-Steuergerät und Verfahren zum Ansteuern von hydraulischen Komponenten
DE102005016801A1 (de) Verfahren und Rechnereinheit zur Fehlererkennung und Fehlerprotokollierung in einem Speicher
DE102018219700B4 (de) Steuervorrichtung
WO2023232401A1 (de) Verfahren für einen betrieb eines steuergeräts eines fahrzeuges
EP1915687A1 (de) Verfahren und vorrichtung zur steuerung eines rechnersystems mit wenigstens zwei ausführungseinheiten
DE102022125619A1 (de) Verfahren zum Starten einer Datenverarbeitungseinrichtung, Datenverarbeitungseinrichtung und Kraftfahrzeug
WO2003025936A2 (de) Verfahren zur erkennung von speicherfehlern in elektronischen bremssystemen, rechnersystem und dessen verwendung
DE102023004853A1 (de) Verfahren zur Fehlerbehebung von sicherheitsrelevanten mikrocontrollergesteuerten Anwendungen in einem Kraftfahrzeug, sicherheitsrelevanten Computerprogrammprodukt, sicherheitsrelevanten Mikrocontroller, sowie Kraftfahrzeug
DE102024132407A1 (de) Mikrocontroller-Einheit, Verfahren und Computerprogramm zur Änderung von Anwendungen
DE10229817A1 (de) Verfahren und Vorrichtung zum Ablegen eines Computerprogramms in einen Programmspeicher eines Steuergeräts
DE102023134299A1 (de) Fahrzeugbewegungsmanager, fahrzeugsteuerungsverfahren und nicht transitorisches speichermedium

Legal Events

Date Code Title Description
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: UNKNOWN

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE INTERNATIONAL PUBLICATION HAS BEEN MADE

PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE

17P Request for examination filed

Effective date: 20251106

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC ME MK MT NL NO PL PT RO RS SE SI SK SM TR