WO2016050857A1 - Verfahren zur datenverarbeitung zum ermitteln, ob bei einer ausführung eines programms ein fehler aufgetreten ist und datenverarbeitungsanordnungen zum erzeugen von programm-code - Google Patents

Verfahren zur datenverarbeitung zum ermitteln, ob bei einer ausführung eines programms ein fehler aufgetreten ist und datenverarbeitungsanordnungen zum erzeugen von programm-code Download PDF

Info

Publication number
WO2016050857A1
WO2016050857A1 PCT/EP2015/072585 EP2015072585W WO2016050857A1 WO 2016050857 A1 WO2016050857 A1 WO 2016050857A1 EP 2015072585 W EP2015072585 W EP 2015072585W WO 2016050857 A1 WO2016050857 A1 WO 2016050857A1
Authority
WO
WIPO (PCT)
Prior art keywords
coded
encoded
multiplier
program
numerical values
Prior art date
Application number
PCT/EP2015/072585
Other languages
English (en)
French (fr)
Inventor
Christof Fetzer
Dmitrii Kuvaiskii
Original Assignee
Technische Universität Dresden
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 Technische Universität Dresden filed Critical Technische Universität Dresden
Publication of WO2016050857A1 publication Critical patent/WO2016050857A1/de

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR 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/085—Error detection or correction by redundancy in data representation, e.g. by using checking codes using codes with inherent redundancy, e.g. n-out-of-m codes

Definitions

  • the invention relates to data processing methods for determining whether an error has occurred during execution of a program, methods for generating program code, data processing arrangements for determining whether an error has occurred during execution of a program, and data processing arrangements for generating program programs. Code.
  • the software can run on multiple hardware components and the results can be compared.
  • the software can be set to two or three
  • Another approach is to split a processor into an insecure and a secure processor component.
  • Results for verifying the secure processor component which outputs the result, if correct, and otherwise causes recalculation.
  • Hardware-based approaches incur high costs, even if only a portion of the hardware is protected because additional space is needed on the chip. Therefore, these approaches are only used in high-end systems, but not in standard hardware or mass hardware.
  • Algorithm-based error tolerance and self-checking software uses invariants to verify the validity of the generated results. There are often no suitable ones
  • the runtime of an AN coded program may slow down up to 100 times.
  • the Running time of a program coded with ANB or ANBD code can even slow down by up to 300 times.
  • the invention is based on the problem
  • a method of data processing for determining whether an error has occurred during execution of a program executing encoded program code, performing at least one of
  • the method may include determining whether an error has occurred in executing the program based on first one or more numerical values encoded by an arithmetic code having a first multiplier and corresponding to one or more operands of the at least one instruction and executing the at least one instruction based on second coded on or a plurality of numerical values encoded by the arithmetic code having a second multiplier and corresponding to one or more operands of the at least one instruction.
  • the method may include determining whether an error has occurred in executing the program based on first one or more
  • the method may include linking, e.g. adding, the first and second, respectively, one or more result values of executing an instruction having a first and a second accumulated result value, respectively
  • the first and second accumulated result values may each be stored, e.g. in a first and second accumulator, e.g. in each case in a register. Further, determining whether an error has occurred in the execution of the program may be accumulated on the first one
  • the first and second accumulated results can be initialized. Further, the first and second accumulated results may be initialized after determining whether an error has occurred and before further encoded first or second encoded one or more result values with the first and second, respectively
  • the method may further include determining a first memory address signature based on a first memory address, concatenating the first encoded one or more numerical values with the first memory address signature using an exclusive or (XOR) operation, and storing the first linked encoded one or more numerical values in a memory at the first memory address.
  • the method may include determining a second memory address signature based on a second memory address, associating the second encoded one or more numeric values with the second memory address
  • Memory address signature by means of an exclusive or (XOR) operation, and storing the second concatenated coded one or more numerical values in a memory at the second memory address.
  • the method may include loading the first coded one or more numerical values from the memory at the first memory address, associating the loaded first one or more numeric values with the first memory address signature using the exclusive or (XOR) operation, loading the second encoded one or more numerical values from the memory at the second memory address, and associating the loaded second one or more numerical values with the second memory address signature by means of the exclusive or (XOR) operation.
  • determining whether an error has occurred in the execution of the program may include determining whether an error has occurred in loading the first or second encoded one or more numerical values based on the loaded first and second encoded one or more
  • the loaded first and second one or more encoded numerical values may be linked to the first and second accumulated result values, e.g.
  • the first memory address signature may be based on a first base memory address and / or the first memory address.
  • the second memory address signature may be on a second base memory address and / or the second
  • each other e.g. Data of a field or buffer, with a base address signature of the field and / or with a memory address signature of the respective memory cell
  • Each field may have its own memory address signature.
  • Writing memory to another buffer may result in a signature that is not expected for the other buffer. This can easily be detected when loading the data.
  • the above method ensures high data integrity and is particularly well suited for applications where data integrity is particularly important. Even if an attacker knew all the multipliers and addresses, there is little chance that the other attacked buffer will have the correct codeword.
  • the method may include decoding a first and second encoded numerical value into a decoded numerical value using a difference of the encoded first and second numerical values, and selecting the first multiplier and the second multiplier such that decoding of the encoded first and second numerical values into a decoded numerical value by means of a difference of the coded first and second numerical values is possible.
  • decoding the encoded first and second numerical values into a decoded numerical value may shift the digits of the result value of the difference of the encoded first and second numerical values in the direction of
  • first multiplier and the second multiplier are selected such that the decoding of the first and second encoded numerical value to a decoded numerical value by means of the difference of the first and second encoded numerical value followed by the shifting of the numerals is possible.
  • Shift operations e.g. Bit shifts
  • the above coding is particularly efficient and may require less compute-intensive operations than
  • a discrepancy or an error may be detected when one of the redundant embodiments uses one wrong operation and another one
  • the first multiplier may be subtracted equal to the second multiplier by a base number high of an exponent number.
  • the base number can be equal to two, and moving the digits can be a bit-shifting of the digits around the
  • Different parts of a system e.g. different computer programs or different parts of a computer program may be coded with different first and second multipliers, e.g. be coded with first and second multipliers such that in each case a different value of the difference of the first and the second
  • the method may include correcting an erroneous decoded numerical value using a coded first and second numerical value, each corresponding to the decoded numerical value.
  • the arithmetic code may be an arithmetic code with or without signatures. With a redundantly executed coding by means of an arithmetic code without signatures can with higher
  • Performance similar to many errors are detected as in a conventional encoding using an arithmetic code with signatures.
  • Processing unit and in memory, e.g. in the
  • the arithmetic code may include at least one code among a group of codes consisting of: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code and an ANBDmem code.
  • the arithmetic code comprises the AN code.
  • determining whether an error has occurred in the execution of the program may be performed by means of a verify circuit. Further, the method may include transmitting the first encoded one or more result values, the first multiplier, the second encoded one or more result values, and the second multiplier from the program to the checker circuit.
  • the method may be performed by means of a verify circuit.
  • the verification circuit may be implemented outside the program.
  • the verification circuit can also be protected by redundancy. Furthermore, the checking circuit may be protected by arithmetic codes.
  • Execution of a program has occurred, generating a program code section for encoding one or more operands of at least one instruction of the program
  • Numerical values using the arithmetic code comprising a second multiplier, generating a program code section for executing the at least one instruction on the first coded one or more numerical values, and generating a program code section for executing the at least one instruction on the second encoded one or more numerical values.
  • the procedure can be
  • the program code for determining whether an error has occurred in executing a program e.g. the coded program code will be generated automatically.
  • the program code may be coded manually, for example the program code to be protected and coded may be kept as small as possible and coded manually.
  • the method may include generating a program code portion for determining a first memory address signature based on a first memory address, generating a program code portion for associating the first encoded one or more
  • the method may include generating a program code section for determining a second memory address signature based on a second memory address, generating a program code section for associating the second encoded one or more numerical values with the second memory address signature using a second memory address signature
  • the method may include generating a program code section for loading the first encoded one or more numerical values from the memory at the first memory address, generating a program code section for associating the loaded first one or more numeric values with the first memory address first memory address signature by means of the exclusive or (XOR) operation
  • the program code section to determine the first one
  • Memory address signature may also be generated such that the first memory address signature is based on a first base memory address and / or the first memory address, and the program code portion for determining the second memory address signature may be generated such that the second memory address signature Memory address signature based on a second base memory address and / or the second memory address.
  • the method may include generating a program code portion for decoding a first and second encoded numerical value into a decoded numerical value using a difference of the encoded first and second numerical values and generating the program code portion for selecting the first multiplier and of the second multiplier such that decoding of the coded first and second numerical values into a decoded numerical value is possible by means of a difference of the coded first and second numerical values.
  • a program code section for shifting the digits of the result value of the difference of the encoded first and second numerical values toward the digit position having the lowest value be generated.
  • the program code section for selecting the first one Multiplier and the second multiplier can be generated such that the first multiplier and the second multiplier are selected such that the decoding of the first and second coded numerical value to a
  • decoded numerical value is possible by means of the difference of the first and second encoded numerical value followed by the shifting of the digits.
  • the method may include generating a program code section for correcting an erroneous decoded numerical value by means of coded first and second
  • the arithmetic code may be an arithmetic code with or without signatures.
  • the arithmetic code may include at least one of a group of codes consisting of: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, and an ANBDmem code.
  • the arithmetic code has the AN code.
  • Execution of a program has occurred an error, a circuit for executing coded program code, a first instruction execution circuit for execution
  • the data processing device may include a determination circuit for determining whether an error has occurred in executing the program based on first one or more result values of executing the at least one instruction on the first encoded one or more numerical values and the first one
  • Execution of a program a receive circuit for receiving first encoded one or more result values, a first multiplier, second encoded one or more result values, and a second multiplier from the program in a check circuit outside the program.
  • the first encoded result value may be determined in the program when executing at least one instruction based on first encoded one or more numerical values, the first encoded one or more numerical values corresponding to one or more operands of the at least one instruction and having a first arithmetic code Multiplier are coded.
  • the second encoded result value may have been determined in the program in executing at least one instruction based on second encoded one or more numerical values, the second encoded one or more numerical values corresponding to one or more operands of the at least one instruction and having a second one by means of the arithmetic code Multiplier are coded.
  • the data processing arrangement may comprise a determination circuit for determining in the verification circuit whether an error has occurred in the execution of the program based on the first encoded one or more
  • Program code for determining whether an error has occurred in executing a program; a first coding program code section generating circuit for generating a program code section for encoding one or more operands of at least one instruction of the program in FIG first encoded one or more numerical values by means of an arithmetic code having a first multiplier, a second encoding program code section generating circuit for generating a program code section for encoding the one or more operands of the at least one instruction into second ones or a plurality of encoded numerical values by means of the arithmetic code having a second multiplier, a first instruction execution program code section generating circuit for generating a program code section for executing the at least one instruction on the first encoded one or more
  • Numerical values and a second instruction execution program code section generating circuit for generating a program code section for executing the at least one instruction on the second encoded one or more
  • the data processing arrangement may include a determination program code section generation circuit for generating a program code section for determining whether or not execution of the program
  • Embodiments executes.
  • FIG. 1 shows a flow chart illustrating a method for
  • FIG. 2 shows a flow chart illustrating a method for
  • FIG. 3 shows a flowchart illustrating a method for generating program code for determining whether an error has occurred during execution of a program, according to an exemplary embodiment.
  • FIG. 4 shows a data processing arrangement for determining whether an error has occurred during the execution of a program, according to one exemplary embodiment.
  • FIG. 5 shows a data processing arrangement for determining whether an error has occurred in a program execution, according to a further exemplary embodiment.
  • Figure 6 shows a data processing arrangement for generating program code for determining whether an error has occurred in a program execution, according to one embodiment.
  • FIG. 7 shows a data processing arrangement according to an exemplary embodiment.
  • FIG. 8 shows a representation according to FIG
  • Embodiment illustrating the coding and execution of a program, as well as the decoding and checking of the coded result.
  • FIG. 9 shows a representation according to FIG.
  • Embodiment which has a memory with two
  • FIG. 10 shows a data processing arrangement according to FIG.
  • Fig.l shows a flowchart 100, which is a method for
  • a coded program code may be executed.
  • the coded program code may correspond to at least one code section of the program to be executed.
  • At 104, at least one instruction of the encoded program code may be based on first encoded one or more
  • arithmetic codes comprising a first multiplier and one or more operands corresponding to the at least one instruction.
  • the at least one instruction may be executed based on second coded one or more numerical values encoded by the arithmetic code having a second multiplier and also corresponding to the one or more operands of the at least one instruction
  • the statement can be duplicated, first on the first coded one or more
  • Numerical values are executed and then executed on the second coded one or more numerical values or vice versa.
  • the instruction may also be duplicated and executed in parallel on the first and second coded one or more numerical values.
  • An error has occurred in the program based on first one or more result values of executing the at least one instruction on the first coded one or more numerical values and the first multiplier and / or based on second one or more result values of executing the at least one instruction on the second encoded one or more numerical values and the second multiplier.
  • Information level can be added redundancy.
  • the data can not only be encoded, but also duplicated. All statements that are executed on this data can also be duplicated.
  • the sum of two inputs may be encoded as two sums, with each sum executed on a coded copy of the inputs. All instructions can be executed on the encoded data without decoding the data in between.
  • one addition may encode two
  • each time after executing one or more instructions on the first encoded one or more numerical values and on the second encoded one or more numerical values it can be repeatedly determined whether an error has occurred.
  • one or more duplicate instructions may be executed, then it may be determined if an error has occurred, and then further one or more duplicate instructions may be executed for which it may be determined
  • the first and second one or more result values of executing an instruction may be associated with a first
  • Result value can be stored, e.g. in a first and second accumulator, e.g. in each case one
  • determining whether an error has occurred in the execution of the program may be accumulated on the first one
  • the first and second accumulated results can be initialized. Further, the first and second accumulated results may be initialized after determining whether an error has occurred and before further encoded first or second encoded one or more result values with the first and second, respectively
  • the first and second one or more result values of executing an instruction may be the first and second encoded one or more numerical values for executing another instruction.
  • the first encoded one or more numerical values of the one and the other first instructions may have the same first multiplier and the second encoded one or more
  • Numerical values of one and the other second instruction may have the same second multiplier.
  • different instructions may each have a different first and second multiplier, respectively.
  • Executing the one or more duplicate instructions of the coded program code also executes instructions of the program which are not coded. All instructions or all safety-critical instructions can be executed as duplicated statements of the coded program code. In different
  • all instructions of the encoded program code may be executed on encoded data without decoding or re-encoding the encoded data between executions.
  • a first memory address signature can be determined based on a first memory address.
  • a second memory address signature may be determined based on a second memory address. The first or the second memory address signature may be known. Furthermore, the first coded one or more
  • Numerical values with the first memory address signature by means of a self-inverse operation, e.g. an exclusive or (XOR) operation.
  • the first coded one or more numerical values thus linked may be stored in a memory at the first memory address, for example in a register, a cache or a random access memory.
  • the second encoded one or more numerical values may be associated with the second memory address signature by means of the self-inverse function, e.g. of the
  • the second coded one or more numerical values thus linked may be stored in a memory at the second
  • Memory address are stored. Clearly, data can be linked to a memory address signature before being stored, which can be checked when the data is loaded.
  • the first and / or second one or more result values can be analogous to the above for the coded numerical values
  • the first coded one or more numerical values may be loaded from the memory at the first memory address.
  • the loaded first coded one or more numerical values may be associated with the first memory address signature by means of a self-inverse function, e.g. Exclusive or (XOR) operation.
  • the second coded one or more numerical values may be from the memory at the second
  • encoded one or more numerical values may be encoded with the second memory address signature by means of the self-inverse function, e.g. Exclusive or (XOR) operation.
  • self-inverse function e.g. Exclusive or (XOR) operation.
  • determining whether an error has occurred in the execution of the program may further comprise determining whether one or more numerical values are encoded in loading the first or second encoded
  • the charged first and second accumulated numerical values may be accumulated with the first and second, respectively
  • Result value e.g. be added.
  • the first memory address signature may be on a first base memory address and / or the first memory address be based.
  • the first base memory address may be uniquely assigned to a first memory area.
  • the second base memory address may be uniquely assigned to a second memory area.
  • the first base memory address may be equal to the second
  • Base memory address e.g. if the first coded
  • the first base memory address may be different from the second base memory address, e.g. if the first coded numerical values and the second coded numerical values are in different, logically separated
  • Memory areas are stored. Further first coded numerical values can be in one
  • Memory area are stored, to which a further first base address is assigned.
  • Memory area are stored, which is associated with another second base address.
  • ⁇ there may be one or more storage areas. Data that is related to each other may be stored in a memory area, e.g. a field or buffer,
  • Base memory address mark a first memory area, for example, the start address of a first buffer
  • Another base memory address may mark a second memory area, for example marking the start address of a second buffer.
  • it can be detected when encoded one or more numerical values overwrite other coded one or more numerical values when storing, or vice versa. It can each different buffers different
  • Base address signature based on the base address of the respective buffer. Linking a value to be stored with the base address signature by means of e.g.
  • Exclusive or (XOR) operation allows to detect if this value is the value of another
  • the value may be stored with a memory address value based on the memory address within the buffer to which the value is to be stored, by e.g. exclusive or (XOR) operation for detecting when one or more values of a buffer are stored at a wrong memory address within the buffer.
  • exclusive or (XOR) operation for detecting when one or more values of a buffer are stored at a wrong memory address within the buffer.
  • a first and a second encoded numerical value may be decoded into a decoded numerical value by means of a difference of the encoded first and second numerical values.
  • the first multiplier and the second multiplier may be selected such that decoding the encoded first and second numerical values into a decoded one
  • Numerical value by means of a difference of the coded first and second numerical value is possible.
  • the first and the second multiplier may be predetermined.
  • the first and second multipliers may be determined or selected outside of the program, for example, in FIG a verification circuit. In different
  • Multiplier when compiling or interpreting the program are selected or determined.
  • the first encoded numerical value may include a numerical value of the first encoded one or more numerical values and the second encoded numerical value
  • Number can be a first encoded numerical value
  • One, several or all of the first and second coded one or more numerical values may be decoded.
  • Result values are decoded and unencoded one or more numerical values (in other words input values or
  • Result values of an unencoded instruction may be encoded into first and second encoded one or more numerical values and used as encoded first and second one or more numerical values for a coded instruction.
  • decoding the encoded first and second numerical values into a decoded numerical value may further include shifting the digits of the numerical value
  • Multiplier be selected such that the decoding of the first and second coded numerical value to a
  • decoded numerical value by means of the difference of the first and second coded numerical value followed by the shifting of the Numbers is possible.
  • decoding data only subtraction and shift operations, eg bit shifts, can be performed.
  • the above coding is particularly efficient.
  • the first multiplier may be subtracted equal to the second multiplier by a base number high of an exponent number.
  • the base number may be equal to the number 2 and the shifting of the digits may be a bit shift of the digits by the exponent number.
  • an erroneous decoded numerical value may be corrected by means of a coded first and second value corresponding respectively to the decoded numerical value.
  • one, several, or all incorrectly decoded numerical values may include one, several, or all values of the first and second one or more coded and decoded numerical values
  • the erroneous first or second encoded one or more numerical values corresponding to the erroneous decoded one or more numerical values may be corrected.
  • the first or second coded one or more numerical values corresponding to the erroneous decoded one or more numerical values can be corrected by means of the second or the first coded one or more numerical values.
  • the erroneous first or second corresponding to the erroneous decoded one or more numerical values may include one or more
  • first and second encoded one or more result values corresponding to the erroneous decoded one or more numerical values may be corrected by means of the second and the first coded one or more result values, respectively.
  • the arithmetic code may be an arithmetic code with or without signatures.
  • the arithmetic code may include at least one of the following codes or at least one of the following codes: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code or an ANBDmem code.
  • the arithmetic code has the AN code.
  • the arithmetic code may be any arbitrary arithmetic code that allows the first and second encoded one or more numerical values to be decoded by subtraction and bit shifting.
  • the arithmetic code may be any arbitrary arithmetic code containing the
  • determining whether an error has occurred in the execution of the program may be performed by means of a verify circuit.
  • the verification circuit may have the first and second accumulated result values, respectively.
  • the first and second received one or more result values may be from the verification circuit having the first and second, respectively
  • accumulated result value e.g. be added.
  • first and second accumulated result values can be transmitted from the program to the checking circuit and received there.
  • the checking circuit may accumulate a first or second received one
  • Verify circuit determine the first and second accumulated result value. Both the program and the checker circuit may each determine a first and second accumulated result value, respectively. For example, the program may retrieve data after each executed statement or after several instructions have been executed
  • Submit verification circuit In various embodiments, the method may be performed by means of a verify circuit. In various embodiments, the coded
  • Program code identify an interpreter program that safely loads, interprets and executes the program.
  • the interpreter program can be used with the
  • Program code having a code for loading and checking values, e.g. of stored instructions, theirs
  • the redundantly executed at least one instruction may correspond to an instruction for loading coded one or more result values to be checked and / or the associated multiplier.
  • the encoded one or more result values may correspond to the instructions to be loaded, their operands, or already calculated result values.
  • a plurality of numerical values corresponding to the operand of the executed load instruction may have coded memory addresses at which the values to be loaded are stored.
  • Program code have a code for loading and / or
  • the verification circuit may be implemented outside the program.
  • the verification circuit may determine
  • the verification circuitry may be implemented in secure hardware.
  • the verification circuit may be implemented in software.
  • the verification circuit may be coded
  • the verification circuit may be protected by arithmetic codes.
  • FIG. 2 shows a flowchart 200 which describes a method for
  • first encoded one or more result values, a first multiplier, second encoded one or more result values, and a second multiplier may be received by the program in a checker circuit.
  • the first encoded result value may be determined in the program when executing at least one instruction based on first encoded one or more numerical values, the first encoded one or more numerical values corresponding to one or more operands of the at least one instruction and having a first arithmetic code Multiplier can be coded.
  • the second encoded result value may have been determined in the program when executing at least one instruction based on second encoded one or more numerical values, the second encoded one or more
  • Numerical values may correspond to one or more operands corresponding to at least one instruction and may be coded by means of the arithmetic code having a second multiplier.
  • the verification circuitry may be implemented outside the program.
  • Check Circuit checks the values to determine if an error has occurred during execution of the program.
  • the parameters with which the values are coded are or become known to the checking circuit
  • first one or more numerical values may be stored from the memory at a first
  • Memory address will be loaded and a first
  • Memory address to be determined.
  • the loaded first one or more numerical values can match the first one
  • Second one or more numerical values may be loaded from the memory at a second memory address, a second memory address signature may be determined based on the second memory address, and the loaded second one or more numerical values may be associated with the second memory address signature by means of the exclusive or (XOR ) Operation.
  • the loaded first one or more numerical values may include the first coded one or more result values and the first multiplier, and the second one or more numerical values may include the second coded ones several result values and the second multiplier
  • the second multiplier may be the loading of the first and second
  • the verification circuit may have first and second accumulated result values, e.g. a first and second accumulator, e.g. one register each, and
  • the verification circuit may be configured to initialize the first and second accumulated results, e.g. after it has been determined whether an error has occurred and before further first or second encoded one or more result values with the first and second, respectively
  • the checking circuit it may be determined whether an error has occurred in the execution of the program based on the first accumulated result value and the first multiplier and / or based on the second accumulated result value and the second multiplier.
  • the first and second encoded one or more result values may be decoded into decoded one or more result values by a difference of the first and second encoded one or more result values.
  • the first multiplier and the second multiplier can be chosen such that decoding the
  • decoded result value by means of a difference of the coded first and second result value is possible.
  • first and / or second decoded one or more result values may be transmitted to an output unit. There may be one or more faulty decoded ones
  • Result values are corrected by means of first and second coded one or more result values corresponding respectively to the decoded one or more result values. Furthermore, the erroneous first or second encoded one or more result values corresponding to the erroneous decoded one or more result values
  • Result values corresponding to first and second coded one or more result values can be corrected by means of the second or the first coded one or more result values.
  • the transmitting may include combining the first and / or the second encoded one or more result values with the first or second memory address signature by means of an exclusive or (XOR) operation, respectively, and the first and / or the second encoded one or more result values in a memory at each of the first or the second memory address.
  • the arithmetic code can be an arithmetic code with or without signatures.
  • the arithmetic code may include at least one of the following codes or at least one of the following codes: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, or an ANBDmem code , In advantageous embodiments, the arithmetic code has the AN code.
  • the arithmetic code may be any arithmetic code that includes the
  • the arithmetic code may be any arbitrary arithmetic code that allows the first and second encoded one or more encoded numerical values to be decoded without division.
  • the verification circuit can be in secure hardware
  • the verification circuit can be protected by redundancy.
  • the checker circuit may be protected by arithmetic codes.
  • FIG. 3 shows a flowchart 300 which describes a method for
  • a program code section for encoding one or more operands of at least one instruction of the
  • Program in first coded one or more numerical values be generated by means of an arithmetic code having a first multiplier.
  • a program code portion may be generated for encoding the one or more operands of the at least one instruction into second one or more encoded numerical values using the arithmetic code having a second multiplier.
  • coded constants can be calculated entirely from uncoded constant operands having only constant values (in other words, values known at the time of generation).
  • a program code portion for executing the at least one instruction on the first encoded one or more numerical values may be generated.
  • a program code section for executing the at least one instruction may be generated on the second encoded one or more numerical values.
  • a program code portion may be generated for determining whether an error has occurred in executing the program code based on first one or more
  • program code can be used to determine if an error occurs when this program code is executed.
  • a program code section may be generated for linking, e.g. for adding the first or second encoded one or more
  • a program code section may be generated for initializing the first and second, respectively
  • accumulated result e.g. at the beginning of the program execution and / or after determining if an error has occurred before the next one or more result values are associated with the respective accumulated result.
  • a program code section for determining a first memory address signature based on a first memory address, a program code section for linking the first coded one or more numerical values to the first memory address signature by means of a
  • a program code section for determining a second memory address signature based on a second memory address, a program code section for linking the second coded one or more numerical values with the second memory address signature by means of a
  • a program code section for loading the first coded one or more numerical values from the memory at the first memory address and a program code section for associating the loaded first one or more numerical values with the first memory address signature by means of
  • It may include a program code section for loading the second coded one or more numerical values from the memory at the second memory address and a program code section for associating the loaded second one or more
  • Numerical values are generated with the second memory address signature by means of the exclusive or (XOR) operation.
  • a program code section for determining whether an error has occurred in the execution of the program code when generating a program code section for determining whether an error has occurred in the execution of the program code, further, a program code section for determining whether to load the first or second encoded one may be generated or multiple numeric values an error has occurred
  • a program code section can be generated for linking the loaded first or second coded one or more numerical values with the first and second accumulated result values, respectively.
  • the program code section for determining the first memory address signature can be generated such that the first memory address signature is stored on a first base memory address and / or the first memory address signature
  • Memory address is based.
  • the program code section for determining the second memory address signature can be generated in such a way that the second memory address signature is stored on a second base memory address and / or the second memory address signature
  • Memory address is based.
  • a program code section for decoding a first and second encoded numerical value may be decoded
  • Numerical value can be generated by means of a difference of the coded first and second numerical value.
  • the program code section for selecting the first multiplier and the second multiplier may be generated such that decoding of the coded first and second numerical value to a decoded numerical value by means of a difference of the coded first and second numerical value is possible.
  • a program code section for shifting the digits of the result value of the difference of the encoded first and second numerical values toward the digit position having the lowest Value to be generated may be generated such that the first multiplier and the second multiplier are selected such that the decoding of the first and second coded numerical values into one
  • decoded numerical value is possible by means of the difference of the first and second encoded numerical value followed by the shifting of the digits.
  • the program code section for selecting the first one is possible by means of the difference of the first and second encoded numerical value followed by the shifting of the digits.
  • the multiplier and the second multiplier may be generated such that the first multiplier is equal to the second multiplier subtracted by a base number high of an exponent number.
  • Multiplier are generated such that the base number is equal to the number 2 and the shifting of the digits is a bit shift of the digits to the exponent number.
  • a program code section for correcting an erroneous decoded numerical value may be generated by means of coded first and second values respectively corresponding to the decoded numerical value.
  • the arithmetic code can be an arithmetic code with or without signatures.
  • the arithmetic code may include at least one of the following codes or at least one of the following codes: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, or an ANBDmem code , In advantageous embodiments, the arithmetic code has the AN code.
  • FIG. 4 shows a data processing arrangement 400 for
  • the data processing device 400 includes a determination circuit 408 for determining whether an error has occurred in executing the program based on first one or more result values of executing the at least one instruction on the first encoded one or more numerical values and the first one
  • the circuit 402, the first instruction execution circuit 404, the second instruction execution circuit 406, and the determination circuit 408 may be connected via a connection 410,
  • a line For example, a line, a plurality of separate lines, a bus, or communicate with each other by means of a wireless connection and exchange information.
  • the data processing arrangement 400 may be an arrangement for executing a program to be checked for errors or monitored.
  • the arithmetic code may be an arithmetic code with signatures.
  • the arithmetic code may be an arithmetic code without signatures.
  • the arithmetic code may be any arbitrary arithmetic code containing the
  • the arithmetic code may be any arbitrary arithmetic code that allows the first and second encoded one or more encoded numerical values to be decoded without division.
  • the arithmetic code may include at least one of the following codes or at least one of the following: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, or an ANBDmem. Code.
  • the arithmetic code has the AN code.
  • Fig. 5 shows a data processing device 500 for
  • an error has occurred which comprises a receive circuit 502 for receiving first coded one or more result values, a first multiplier, second coded one or more result values, and a second multiplier from the program in a check circuit, the first coded one Result value in the
  • Program has been determined when executing at least one instruction based on first coded one or more numerical values, wherein the first coded one or more
  • Numerical values correspond to one or more operands corresponding to at least one instruction and encoded by means of an arithmetic code having a first multiplier, and wherein the second encoded result value in the program at
  • the data processing device 500 includes a determination circuit 504 for determining in the verification circuit whether an error has occurred in the execution of the program based on the first encoded one or more
  • the receiving circuit 502 and the determining circuit 504 may be connected via a connection 506, such as a wire, a plurality of separate ones Wires, a bus, or communicate with each other via a wireless connection and exchange information.
  • the verification circuitry may be implemented outside the program.
  • the data processing device 500 may be an arrangement for executing a program to be checked for errors or monitored.
  • the arithmetic code may be an arithmetic code with signatures.
  • the arithmetic code may be an arithmetic code without signatures.
  • the arithmetic code may be any arbitrary arithmetic code containing the
  • the arithmetic code may be any arbitrary arithmetic code that allows the first and second encoded one or more encoded numerical values to be decoded without division.
  • the arithmetic code may include at least one of the following codes or at least one of the following: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, or an ANBDmem. Code.
  • the arithmetic code has the AN code.
  • Fig. 6 shows a data processing arrangement 600 for generating coded program code for determining whether a
  • Execution of a program has encountered an error including a first code program code section generating circuit 602 for generating a program code section for encoding one or more operands of at least one instruction of the program into first coded one or more numerical values having an arithmetic code a first multiplier and a second coding program code section generating circuit 604 for
  • the data processing arrangement 600 has a first instruction execution program code section generation circuit 606 for generating a program code section for executing the at least one instruction on the first coded one or more numerical values and a second instruction execution Program code section generation circuit 608 for generating a program code section for executing the at least one instruction on the second coded one or more numerical values, and a determination program code section generation circuit 610 for generating a program code section Program code section for
  • Encoding program code section generation circuit 602 second encoding program code section generation circuit 604, first instruction execution program code section generation circuit 606, second instruction execution Program code section generation circuit 608 and determination program code section generation circuit 610 may be connected via connection 612,
  • Wires a bus, or communicate with each other via a wireless connection and exchange information.
  • the data processing arrangement 600 can be any data processing arrangement 600.
  • the data processing arrangement 600 can be any type of data processing arrangement 600.
  • Compiler or an interpreter for generating a program Codes that can be executed by a data processor to execute a program.
  • the arithmetic code may be an arithmetic code with signatures.
  • the arithmetic code may be an arithmetic code without signatures.
  • the arithmetic code may be any arbitrary arithmetic code containing the
  • the arithmetic code may be any arbitrary arithmetic code that allows the first and second encoded one or more encoded numerical values to be decoded without division.
  • the arithmetic code may include at least one of the following codes or at least one of the following codes: an AN code, an ANB code, an AND code, an ANDmem code, an ANBD code, and an ANBDmem code , In advantageous embodiments, the arithmetic code has the AN code.
  • Data processing arrangements and methods are provided for automatically monitoring a program flow of arithmetic codes with or without signatures
  • Result values can be inseparable from the control and
  • Data flow depend on the execution of the program protected by the arithmetic code with or without signatures.
  • the frequency of checking the encoded numerical or result values may be adjusted from "after each instruction" to "before output” so that errors may be detected before an erroneous output becomes externally visible.
  • the values needed for coded execution e.g. the parameters of the encoding function or of the arithmetic code can be generated statically during the transformation process and be completely independent of the program, randomly selectable values of any size and / or number, so that a random generation of these values despite transient or permanent errors during execution of the Program with arbitrary probability can be excluded.
  • the protected source code of the program can be before the
  • Execution can then take place at runtime, for example, by a secure watchdog process, e.g. outside the program, or by means of special secure instructions, e.g. within the program, to be reviewed.
  • a secure watchdog process e.g. outside the program
  • special secure instructions e.g. within the program
  • the ⁇ is a ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • this may be achieved by the
  • outputs may be allowed at any point in the program flow.
  • the implementation of "fail-fast" behavior in programs may be enabled, that is, errors may be detected as quickly as possible, which may allow an early response.
  • the ⁇ is a ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • Embodiments can be used in safety-relevant applications, for example in automotive engineering, aircraft technology or medical technology. Embodiments can ensure data integrity and high secure availability of data, which is of paramount importance in various areas, such as security relevant or critical applications to commercial web (network) services.
  • FIG. 7 shows a data processing arrangement 700 according to one exemplary embodiment.
  • the data processing device 700 may be employed as one or more of the above-mentioned data processing devices (for example, as described in FIGS. 4 to 6).
  • the data processing device 700 may include storage media 702 that may include a program 710 or multiple programs as well as input data 712.
  • the program 710 may be a program that can execute one of the above methods, for example one
  • Compilation a program flow that is to be monitored for errors, or a program flow that monitors errors when another program is executed.
  • the input data 712 can contain the source code of the program to be compiled.
  • Data processing device 700 includes a random access memory 704 in which data 714 may be included.
  • the data 714 may be data of a currently executing program
  • the data processing device 700 may include. Further, the data processing device 700 may include a central processing unit 706 ("Central Processing unit 706
  • the data processing arrangement 700 may include secure special hardware 708.
  • secure special hardware 708 For example, the checker circuit or the secure one may have
  • Data processing device 700 may be connected
  • an encoding compiler is provided which
  • the possibility of monitoring the program flow of programs protected by arithmetic codes with or without signatures is provided in order to detect when the execution of the program is interrupted by the program
  • deviations in the data flow of the program may be detected early during the execution of the program with a certain probability.
  • the possibility is created to redundantly store data associated with a memory address signature in order to prevent unauthorized reading and evaluation of this data.
  • the ability to monitor data read from a memory becomes possible
  • an error detection approach may be provided based on
  • an error detection approach may be provided based on
  • the number of SDCs for dual (or multiple) AN encoded programs may be reduced as compared to AN encoded programs.
  • additional errors of exchanged operands may be detected.
  • arithmetic codes may be a technique for detecting hardware errors at run time. Coding can add redundancy to all data words. Valid code words can only be a small subset of all possible data words.
  • the set of all possible data words may be the set of all representable data of a particular size, and the set of code words may be the subset of all possible data words generated by a code.
  • Correctly executed arithmetic operations can obtain the code, ie with a valid code word as input, the output can also be a valid code word.
  • An erroneous arithmetic operation or an operation called with uncoded words can with high probability produce a result which is an invalid code word. According to various embodiments, if one
  • Variable x can be obtained by multiplying its
  • x c modulus A the remainder of x c can be computed when divided by A (which can be called "x c modulus A"), which should be zero for a valid code word.
  • An AN code can detect erroneous operations, i. incorrectly executed operations, and modified operands, such as data resulting from a bit error,
  • An ANB code can also exchange errors
  • Input variable with 0 ⁇ B x ⁇ A can be selected.
  • Version D which counts the variable updates.
  • Embodiments may use an AND or ANBD code implementation that applies versions only to the memory accessed during load and store instructions but not to registers. This code can therefore be called the ANDmem or ANBDmem code.
  • the coded version of this function f can only use coded, eg AN, ANB, AND or ANBD coded data i ix t c. f (int_cxc, intc_c, in t_czc) ⁇
  • the decelerations can range from a factor of 2 (eg for the Eratosthenes sieve) to a factor of 75 (eg for an implementation of a traffic warning and collision avoidance system for aircraft), as the case may be Whether the applications use expensive coded operations such as multiplication or floating-point operations.
  • the ANB code may on average be 1.9 times slower than the AN code because it provides coded control and data flow and the coded operations used
  • the data may be encoded at least twice by the AN, ANB, AND, ANBD encodings, and each operation may be performed on each encoded copy of the data.
  • the data may be encoded at least twice by the AN encoding, e.g. can the
  • the function f can be performed as f (x c i, y c i, z c i) and as f (x C 2, y C 2, z C 2), where the variables x clr y cl and z c i are each encoded with the first multiplier Ai and the variables x C 2, y C 2 and z C 2 are each encoded with the second multiplier A2.
  • any numerical values can be selected, as long as the multiplier pair or the Multiplier pairs by exactly one power with base 2
  • each multiplier pair that may be formed from the two or more different multipliers may be a base 2 power
  • Multiplier pairs associated with result values of an executed operation being compared e.g. decoded, verified or verified to distinguish a power with base 2.
  • each multiplier may be greater than the number 1. According to embodiments, anyone can
  • Multiplier be an integer. According to embodiments, each multiplier may have one or more decimal places.
  • the data may be encoded three or four times by the AN encoding, and each operation may be performed on every encoded copy of the data.
  • the data may be coded twice or even more often by the AN-coding and each operation can be performed on each of two coded copies of the data.
  • each two coded copies of a numerical value from the at least two coded copies of the numerical value may be decoded into a decoded numerical value by shifting the digits of the result of the difference of the coded first and second coded copies in the direction of the digit position having the lowest value.
  • Ai A 2 - 2 1 .
  • Multipliers Ai and A 2 are determined.
  • the at least two coded copies of a numerical value may be checked for valid coding by decoding two copies of the numerical value from the at least two coded copies of the numerical value as described above. Thereafter, the result value of decoding these two copies can be encoded again by means of the associated first and / or second multiplier. The one with the first
  • the multiplier re-encoded value may be compared to the first copy and the value re-encoded with the second multiplier may be compared to the second copy.
  • the result values can also be checked by means of the modulus operation.
  • the special registers accui and accu 2 it is possible to check in each case by means of, for example, the modulus operation, whether they have a valid code word. Further, the special registers accui and accu 2 can be checked together for a valid encoding by each as described above be decoded, the respective result of the decoding again by means of the associated first and / or second
  • Multiplier is coded and the re-encoded values are each compared with the corresponding register accui, 2 .
  • the ⁇ is a ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • Multipliers may be chosen as a multiple of the number 2 in order to use an efficient implementation of the modulus operation.
  • the ⁇ is a ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • Multipliers should not be chosen as a multiple of the number 2 in order to ensure better security against errors, e.g. against bit-flips.
  • erroneous coded numerical values that is to say numerical values which do not correspond to a valid codeword during the checking, can be corrected by means of at least one other coded value, wherein the
  • the erroneous coded numerical value and the at least one other coded value correspond to the desired numerical value.
  • the at least one other coded value that may be used for correcting one
  • operands of a function or operation as well as results can be corrected if they are coded.
  • redundancy because of the redundancy, a higher recognition rate of errors can be achieved than with conventional AN encoding.
  • a higher recognition rate of errors can be achieved than with conventional AN encoding.
  • Arithmetic operations can be efficiently implemented.
  • Multipliers are chosen as in the simply performed AN-coding. This can save additional processing time.
  • FIG. 8 shows an illustration 800 according to an embodiment illustrating delta encoding and execution of a program 802 as well as decoding and verifying the encoded result.
  • the unencoded original program 802 can be read by means of the
  • Parameter pair 804 to a coded program 806, represented by arrow 808.
  • Parameter pair 804 may satisfy condition 810, e.g. that the first one
  • Multiplier Ai is equal to the second multiplier A2 plus the number 1.
  • the parameter pair 804 can also fulfill another condition (not shown), eg that the first one Multiplier Ai is equal to the second multiplier A 2 plus a base 2 power.
  • Each multiplier of the parameter pair 804 may have a
  • arithmetic code e.g. an AN code.
  • Multiplier may also be associated with a different arithmetic code than the second multiplier, e.g., the two multipliers can each be assigned to an AN code and an AND code.
  • the program 802 may include the variables x and y. As a result z, x plus y can be calculated. For the sake of explanation, the variables x and y may be constants.
  • the constant x may be duplicated and the coded copies xi and x2 of the constants may be determined.
  • the constant y can also be duplicated and the coded copies yi and 2 of the constants can be determined.
  • the first copies xi, yi of the constants x and y are added and the second copies X2, y2 of the constants x and y become
  • the coded copies of the constants can be added prior to execution, as long as the parameters for the arithmetic codings at the time of optimization are known.
  • the coded program 806 may be executed coded, represented by the arrow 812. In the executed
  • Program 814 the first and second copies zi and Z2 of the result z can be determined.
  • the coded variables and the coded terms resulting therefrom can already be optimized before execution, ie before coded processing, depending on the variables and parameters, eg converted to terms whose evaluation is more efficient during the execution of the coded program.
  • the parameters of the arithmetic code are already known before the coded processing, then the in this Case constant values zi, 2 are determined in advance, for example as Ai, 2 multiplied by the constant 3.
  • the multipliers Ai A 2 can be determined at the time of encoding 808 and thus at the time of the encoded execution 812 be known.
  • the signatures (not shown) can be used in the case of a dynamic ANB coding
  • Memory management to be assigned 812 only at the time of coded execution.
  • the executed coded program 814 may be decoded, represented by the arrow 816. After decoding 816, a decoded result 818, 820, 822 may be obtained. The decoded result 818, 820, 822 may be checked, represented by arrows 824, 826, 828. For example, it may be checked 824, 826, 828 whether a recoded result value is equal to the corresponding encoded result value. The re-coding and comparing may be for the
  • Parameter pair 804 or for one or more pairs of parameters (not shown) in the event that the program 802 has more than two sets of parameters, e.g. more than two multipliers, coded and executed.
  • a check result 830, 832, 834 may be determined. If the re-encoded redundant result values z 'i, z' 2 equal the encoded ones
  • Multiplier Ai and the value 5 for the second multiplier A 2 be selected.
  • the value 18 can be determined, for example, by means of these parameters Ai, A 2 for the first encoded result zi and the value 15 for the second encoded result Z2.
  • the value 3 can be determined.
  • the decoded result can be coded again by means of the parameters, wherein also the values 15 and 18 can be determined. Therefore, it can be determined as the check result 830 that the decoded result 818 is correct.
  • coded execution 812 In coded execution 812, however, other, incorrect result values can also be determined in the event of an error.
  • the correct value for the first coded result value may be 18, and for the second coded result value, the wrong value 11.
  • the decoded result 820 may be the difference between these two encoded ones
  • Result values result because the difference between the first and the second multiplier according to the condition 810 can be the value 1, which of the number 2 is high of the number 0
  • the wrong value 7 can be determined.
  • Result value is the condition or conditions of the
  • Coding 808 used arithmetic codes meet, so whether they correspond to a valid codeword. In the case of an AN code, this can be done differently by means of the modulus operation
  • the correctly coded result value in this example the first coded result value, can be used to correct (not shown) the error.
  • Result value are decoded to determine the decoded result.
  • coding and / or executing more than twice it is also possible to determine which decoded one
  • Result value was most often determined and this can be selected as a decoded result.
  • Result value is the wrong value 24 and for the second coded result value the wrong value 15 can be determined.
  • the wrong value 9 can be determined.
  • a first check 828 it can be determined that none of the recoded result values match the
  • Check result 834 an error can be detected.
  • a second check 838 whether the coded
  • Multiplier can be selected such that, for example, be chosen sufficiently large that when an error occurs, such as a bit-flip, with a high probability no valid code word results. Even if two valid code words should result due to errors, an error may occur be detected, because none of the recoded result values with the corresponding coded
  • Process 812 determined coded result values
  • program 802 may be encoded 808 (not shown) with different parameter pairs 804 808, each encoded program 806 may be encoded
  • executed encoded program 814 may be decoded 816 and checked 824, 826, 828 and / or an attempt may be made to correct decoded result 818, 820, 822 836, 838.
  • coded program 806 may be re-encoded 812 in the event of an error are processed,
  • encoded program 806 may be re-encoded 812 in the event of an error, more frequently, more often, for potential errors.
  • the decoded result value may be determined as a corrected decoded result that has been most frequently determined.
  • an error may be detected if at least one of the recoded result values does not match the corresponding one in encoded processing 812
  • FIG. 9 shows a representation 900 according to an embodiment, which includes a memory 902 with two buffers 904, 906
  • Each buffer 904, 906 may have a base address 908, 910, e.g. the starting address.
  • a value 918, 920, 922 may be stored, e.g. an encoded numeric value.
  • the encoded numerical value may be linked to a signature which may be based on its memory address 912, 914, 916 by means of an exclusive or (XOR) operation.
  • XOR exclusive or
  • the memory address 912, 914, 916 at which the value 918, 920, 922 is to be stored or from which the value 918, 920, 922 is to be loaded may be encoded, e.g. be coded by means of an ON codes.
  • a first copy of the memory address 912, 914, 916 may be encoded by means of an arithmetic code having a first multiplier and a second copy of the memory address 912, 914, 916 may be encoded by means of a
  • arithmetic codes comprising a second multiplier.
  • each variable to be stored in memory 902 can be encoded by means of a first and a second multiplier.
  • a first coded copy of the variable may be the first encoded value 918 at a first memory address 912
  • a second coded copy of the variable may be used as a second coded value 920 on a second
  • Memory address 914 are stored.
  • the first encoded value 918 and the second encoded value 920 may be stored within the first buffer 904.
  • Variable values may differ from the first and second Differentiate multipliers for encoding memory addresses 910, 912, 914. However, the same first and second multipliers may be used to encode the variables and to encode memory addresses 912, 914, 916, respectively.
  • two or more coded copies of a variable may be stored, e.g. two or more AN encoded copies, each associated with a memory address signature by means of an exclusive or (XOR) operation.
  • XOR exclusive or
  • two or more copies of a memory address 912, 914, 916 may be encoded.
  • memory addresses 912, 914, 916 may be assigned two or more memory address signatures, e.g. ON-coded memory addresses.
  • a memory address 912, 914, 916 may be provided by means of a
  • arithmetic codes comprising a first multiplier, e.g. to a first coded
  • Memory address p A i The memory address 912, 914, 916 can further be coded by means of the arithmetic code having a second multiplier, for example to a second coded memory address p A 2 ⁇
  • a second multiplier for example to a second coded memory address p A 2 ⁇
  • the memory address can be decoded by means of the first and the second encoded memory address, for example by means of the difference of the first and the second encoded memory address, for example by means of the difference followed by a shift, for example by means of the difference followed by a bit shift.
  • the first coded copy of a variable e.g. An AN encoded copy may be stored at the first memory address 912 by being encoded with the first
  • Memory address p x A i of the first memory address and / or with the second encoded memory address p x A 2 of the first Memory address is linked, for example by means of
  • the second coded copy of a variable e.g. An AN encoded copy may be stored at the second memory address 914 by encoding with the first
  • Memory address is linked, e.g. by means of
  • the first coded copy of a variable e.g. An AN encoded copy may be loaded from the first memory address 912 by being encoded with the first
  • Memory address is linked, e.g. by means of
  • the second coded copy of a variable e.g. An AN encoded copy may be loaded from the second memory address 914 by being encoded with the first
  • Memory address is linked, e.g. by means of
  • Memory addresses for example, both encoded memory addresses can be linked together by means of an exclusive or (XOR) operation.
  • XOR exclusive or
  • a memory address signature may include one or more of its corresponding encoded memory addresses. According to various embodiments, it may be detected whether a wrong variable is being loaded from the memory because linking to a memory address signature that is not associated with the loaded variable by means of the exclusive or (XOR) operation is high
  • Probability in an invalid code word results. For example, a variable may be wrong
  • Memory address are stored or loaded from an incorrect memory address when a transient error occurs in the address bus.
  • errors of exchanged operands can be detected.
  • similar guarantees as with ANB coding may be provided when an AN coded value 918, 920, 922 is associated with its memory address signature by means of the exclusive or (XOR) operation.
  • the ⁇ is a ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • a delta encoded program or a delta encoded program may be included
  • Memory address signatures are executed faster than an ANB encoded program.
  • the memory address signature to which a value 918, 920, 922 is linked has a base address signature, the base address 908, 910 being associated with the buffer 904, 906 in which the value 918, 920, 922 is to be stored.
  • An encoded copy of a variable may be stored at the memory address 912, 914, 916 by associating it with a base address signature prior to being stored in the memory 902, each one
  • Buffer 904, 905 has its own base address signature.
  • each buffer 904, 906 may have a
  • Memory address the so-called base address, unique be assigned, based on which the base address signature is determined.
  • the encoded copy may each be encoded with one or more encoded base addresses, and
  • An encoded copy of a variable may be loaded from the memory address 912, 914, 916 by being associated with a base address signature after loading from the memory 902, e.g. is associated with one or more encoded base addresses, and additionally with one or more encoded memory addresses.
  • a stored value 918, 920 in the first buffer 904 is overwritten by a value 922 of the second buffer, whether accidentally or intentionally caused by an overflow of the second buffer 906, this can easily be detected by the base address signature.
  • the value 922 of the second buffer 906 would not be associated with the first base address signature but would be e.g. with the second base address signature in the case of a buffer overflow or with e.g. any guilty or arbitrary
  • Words 918, 920, 922) is linked to the same signatures during storage and loading.
  • numerical values to be stored and coded by means of an arithmetic code are linked by means of a self-inverse operation.
  • to be loaded and by means of the arithmetic code are linked by means of a self-inverse operation.
  • Multipliers are coded.
  • Lifetime of application or program before compiling by coding the source code, during the
  • Variable be doubled at least coded with at least one different multiplier.
  • Embodiments may be provided, as described in more detail below:
  • Basic arithmetic and Boolean operations can be encoded as it is known as such, eg with the AN code. Encoding complex operations like bitwise
  • Logical operations, type conversion, shift operations, or floating point operations may also be encoded as it is known per se. According to embodiments, encoding of data is provided.
  • FIG. 10 shows a data processing arrangement 1000 according to one exemplary embodiment.
  • Source code 1002 may be supplied to a compiler 1004 (eg, a software encoding compiler). Compiler 1004 can then do a secure
  • An encoded execution 1010 of the executable encoded program 1008 may take place.
  • Output values 1014 of the executable encoded program 1008 may be verified by a secure watchdog (in other words, a secure verify circuit 1018), represented by arrow and circle 1022.
  • the verification may be performed by encoded execution 1010 sending encoded numerical values to the secure watchdog 1018, which checks these values. For example, encoded result values or encoded result values
  • Output values 1016 and the associated multipliers are sent to the watchdog 1018.
  • the watchdog can stop the execution of the
  • the two coded one or more output values with the two multipliers can be sent to the checking circuit.
  • the verification circuit now checks the coded outputs. If they have passed the test, the checker circuit decodes the outputs and outputs these decoded outputs.
  • a watchdog circuit may be used to verify the correct ones
  • the verification circuit may be outside of the coded
  • Program be arranged, so for example, no part of the encoded program.
  • the verification circuit may be reliably executed outside the encoded program.
  • secure special instructions may be used to verify the correct execution of the encoded program during its runtime.
  • the secure special instructions may be called from within the encoded program, eg, be part of the encoded program.
  • the secure special instructions may be reliably executed from within the encoded program.
  • all duplicated data is encoded using arithmetic codes and duplicated instructions are executed on the encoded data to detect errors.
  • the program and the processed data are changed.
  • decoding can be performed particularly efficiently without expensive division. Due to the redundant design, it can be detected if a wrong operator is used in one embodiment.
  • Coding linking to memory address signatures, and redundant execution of the coded instructions may cause any high hit rate errors in both the Central processing unit (CPU) as well as in the memory, eg the main memory, eg the random access memory (RAM)
  • CPU Central processing unit
  • main memory eg the random access memory

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Quality & Reliability (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Detection And Correction Of Errors (AREA)

Abstract

In einem Ausführungsbeispiel wird ein Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, bereitgestellt. Das Verfahren weist ein Ausführen von codiertem Programm-Code; ein Ausführen mindestens einer Anweisung des codierten Programm- Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind und ein oder mehreren Operanden der mindestens einen Anweisung entsprechen; und ein Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, auf. Ferner weist das Verfahren ein Ermitteln auf, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.

Description

Beschreibung
Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code
Die Erfindung betrifft Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, Verfahren zum Erzeugen von Programm-Code, Datenverarbeitungsanordnungen zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code.
Es ist zu erwarten,
Hardware (engl . : „c immer weniger
zuverlässig wird au
Integrationsdichte
Generationen von in
Um Hardwarefehler bei Ausführung von Software zu erkennen, kann die Software auf mehreren Hardwarekomponenten ausgeführt werden und die Ergebnisse können verglichen werden. Zum
Beispiel kann die Software jeweils auf zwei oder drei
Hardwarekomponenten ausgeführt werden. Eine Korrektur von aufgetretenen Fehlern ist jedoch erst ab einem Ausführen auf drei Hardware-Komponenten möglich. Weiterhin ist es
kostspielig, die mehreren redundanten Hardwarekomponenten bereitzustellen, z.B. auf einem Chip bereitzustellen.
Weiterhin schützt Diversität allein nur unzureichend gegen permanente Fehler in der Hardware, wenn diese alle
Hardwarekomponenten betreffen. Gerade permanente Fehler werden in der Zukunft häufiger auftreten, weil Hardware bedingt durch schrumpfende Strukturen schneller altert.
Ein anderer Ansatz ist es, einen Prozessor in eine unsichere und eine sichere Prozessorkomponente aufzuteilen. Die
unsichere Prozessorkomponente sendet ihre berechneten
Ergebnisse zum Überprüfen zu der sicheren Prozessorkomponente, die das Ergebnis, wenn korrekt, ausgibt und andernfalls ein erneutes Berechnen veranlasst.
Ferner ist es möglich, einen Arbeitsspeicher, einen Prozessor- Cache oder Register dediziert zu schützen.
Hardware-basierte Ansätze verursachen jedoch hohe Kosten, selbst wenn nur ein Teil der Hardware geschützt wird, weil zusätzlicher Platz auf dem Chip benötigt wird. Daher werden diese Ansätze nur in High-End Systemen eingesetzt, jedoch nicht in Standard-Hardware oder Massen-Hardware.
Aufgrund ökonomischer Faktoren gibt es jedoch Bestrebungen, immer mehr Standard-Hardware mit ungenügender Fehler-Erkennung auch in kritischen Anwendungen zu benutzen. Zudem können nicht erkannte Hardwarefehler bei modernen Computern zu sichtbaren Fehlern der Software führen. Hieraus ergibt sich die
Notwendigkeit, Hardwarefehler bei der Ausführung in Software zu erkennen.
Algorithmus-basierte Fehler-Toleranz und selbstüberprüfende Software nutzt Invarianten zum Überprüfen der Validität der erzeugten Ergebnisse. Es existieren oft keine passenden
Invarianten, die eine gute Fehler-Erkennungs-Möglichkeit bereitstellen.
Andere Software-Ansätze arbeiten mit replizierter Ausführung und Vergleich (und Abstimmung) über die erhaltenen Ergebnisse. Die geschützte Software wird während oder vor dem Compilieren geändert. Einige Ansätze duplizieren einzelne Instruktionen innerhalb eines Ausführungsstranges. Andere verwenden
Duplikate des ganzen Programms unter Verwendung mehrerer
Ausführungsstränge. Bei manchen Ansätzen müssen Anweisungen von Hand eingefügt werden.
Jedoch weisen generische Software-Ansätze eine niedrige
Effizienz auf oder haben spezielle Anforderungen an die
Hardware, z.B. dass der Speicher mittels Fehler-korrigierender Codes (error correcting codes, ECC) geschützt ist oder, dass zwei Prozessorkerne zur parallelen Ausführung von Threads verfügbar sind. Andere Software-Ansätze haben gegenteilige Voraussetzungen und sind z.B. für ein Ausführen mit mehreren Threads ungeeignet. Diese Anforderungen schränken die
Verwendungsmöglichkeiten generischer Software-Ansätze ein.
Generische Software-Ansätze zum Ausführen von Programmen auf verteilten Hardware-Systemen, z.B. Ansätze zum sicheren
Austausch von Nachrichten mittels Replikation der Nachrichten, verdoppeln den benötigten Speicherplatz oder benötigen mehr als dreimal so viele Maschinen wie die Anzahl der gleichzeitig erkannten Fehler. Eine weitere mögliche Lösung zum Detektieren von Hardware- Fehlern in Software ist die Verwendung von arithmetischen Codes, z.B. AN-Codes, der im Folgenden noch näher beschrieben wird. Ein arithmetischer Code weist die Eigenschaft auf, dass bei Anwendung einer arithmetischen Operation auf ein gültiges Codewort ein gültiges Codewort resultiert. Mit der Hilfe von arithmetischen Codes können codierte Programme erzeugt werden. Diese Codes detektieren Hardware-Fehler unabhängig von dem tatsächlichen Fehler-Modus der zugrundeliegenden Hardware. Jedoch haben Messungen gezeigt, dass mit AN-Codes oder mit anderen Codes, die keinen großen Aufwand erfordern, z.B. mit Residuum-Codes, codierte Programme immer noch zu hohe Raten von nicht-erkannten stillen Daten-Fehlern (englisch: „Silent Data Corruption", SDC) enthalten. Diese hohen Raten von unerkannten SDCs werden durch
unzureichenden Schutz des Kontrollflusses (oder Ablaufflusses ) und Datenflusses durch AN-Codes verursacht. Mit ANB- und ANBD- Codes werden höhere Fehler-Erkennungs-Raten erzielt. Jedoch erhöht sich die Laufzeit des Ausführens eines mit AN-, ANB- oder ANBD-Codes codierten Programms erheblich.
Beispielsweise kann sich die Laufzeit eines mit AN-Codes codierten Programms um bis das 100-fache verlangsamen. Die Laufzeit eines mit ANB- oder ANBD-Codes codierten Programms kann sich sogar um bis das 300-fache verlangsamen.
Der Erfindung liegt das Problem zu Grunde,
Datenverarbeitungsanordnungen und Verfahren bereitzustellen zum zuverlässigen und Rechenzeit sparenden Erkennen von
Fehlern in einem Programm-Ablauf.
Das Problem wird durch Verfahren und
Datenverarbeitungsanordnungen mit den Merkmalen gemäß den unabhängigen Patentansprüchen gelöst.
Weiterbildungen ergeben sich aus den abhängigen Ansprüchen. In verschiedenen Ausführungsbeispielen kann ein Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, ein Ausführen von codiertem Programm-Code, ein Ausführen mindestens einer
Anweisung des codierten Programm-Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind und ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, und ein Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, aufweisen. Das Verfahren kann ein Ermitteln aufweisen, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren
Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Anschaulich können sowohl Daten als auch die Anweisungen, die auf diesen Daten ausgeführt werden, dupliziert bzw.
vervielfacht werden. Dabei können beide bzw. alle Kopien der Daten codiert werden. Beispielsweise können die Datenkopien mit jeweils verschiedenen Parametern codiert werden. Dadurch kann eine hohe Fehlerabdeckung erzielt werden. Es können beliebig viele Fehler detektiert werden, z.B. beliebig viele transiente und permanente Fehler, z.B. transiente und
permanente Hardwarefehler. Aufgrund der redundanten codierten Kopien der Daten und der redundant ausgeführten Anweisungen kann verglichen mit einem herkömmlichen Verfahren zusätzlicher Schutz vor permanenten und transienten Fehlern gewährleistet werden. Es kann eine hohe Datenintegrität gewährleistet werden und das obige Verfahren kann sich gut für Anwendungen eignen, bei denen Datenintegrität besonders wichtig ist.
In verschiedenen Ausführungsbeispielen kann das Verfahren ein Verknüpfen, z.B. ein Addieren, der ersten bzw. zweiten ein oder mehreren Ergebniswerte des Ausführens einer Anweisung mit einem ersten bzw. zweiten akkumulierten Ergebniswert
aufweisen. Der erste bzw. zweite akkumulierte Ergebniswert kann jeweils gespeichert werden, z.B. in einem ersten bzw. zweiten Akkumulator, z.B. in jeweils einem Register. Ferner kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, auf dem ersten akkumulierten
Ergebniswert und dem ersten Multiplikator und/oder auf dem zweiten akkumulierten Ergebniswert und dem zweiten
Multiplikator basieren.
Zu Beginn der Programm-Ausführung können das erste und zweite akkumulierte Ergebnis initialisiert werden. Ferner können das erste und zweite akkumulierte Ergebnis initialisiert werden, nachdem ermittelt worden ist, ob ein Fehler aufgetreten ist und bevor weitere erste bzw. zweite codierte ein oder mehrere Ergebniswerte mit dem ersten bzw. zweiten akkumulierten
Ergebniswert verknüpft werden. In verschiedenen Ausführungsbeispielen kann das Verfahren ferner ein Ermitteln einer ersten Speicheradressen-Signatur basierend auf einer ersten Speicheradresse, ein Verknüpfen der ersten codierten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer ausschließlichen oder (XOR) -Operation, und ein Speichern der ersten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der ersten Speicheradresse, aufweisen. Das Verfahren kann ein Ermitteln einer zweiten Speicheradressen-Signatur basierend auf einer zweiten Speicheradresse, ein Verknüpfen der zweiten codierten ein oder mehreren Zahlenwerte mit der zweiten
Speicheradressen-Signatur mittels einer ausschließlichen oder (XOR) -Operation, und ein Speichern der zweiten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der zweiten Speicheradresse, aufweisen.
Weiterhin kann das Verfahren ein Laden der ersten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der ersten Speicheradresse, ein Verknüpfen der geladenen ersten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation, ein Laden der zweiten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der zweiten Speicheradresse, und ein Verknüpfen der geladenen zweiten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation, aufweisen.
Ferner kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, ein Ermitteln aufweisen, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein Fehler aufgetreten ist, basierend auf den geladenen ersten und zweiten codierten ein oder mehreren
Zahlenwerten, dem ersten Multiplikator und dem zweiten
Multiplikator. Ferner können die geladenen ersten bzw. zweiten ein oder mehreren codierten Zahlenwerte mit dem ersten bzw. zweiten akkumulierten Ergebniswert verknüpft werden, z.B.
addiert werden. Anschaulich können Daten, bevor sie gespeichert werden, mit einer Speicheradressen-Signatur verknüpft werden, die beim Laden der Daten überprüft werden kann. Somit können betreffend die zu detektierenden Fehler ähnliche Garantien gegeben werden wie bei einer ANB-Codierung, jedoch ohne als arithmetischen Code einen ANB-Code zu verwenden, z.B. können ausgetauschte Operanden detektiert werden. Die erste Speicheradressen-Signatur kann auf einer ersten Basisspeicheradresse und/oder der ersten Speicheradresse basiert sein. Die zweite Speicheradressen-Signatur kann auf einer zweiten Basisspeicheradresse und/oder der zweiten
Speicheradresse basiert sein.
Beispielsweise können Daten, die in einem Zusammenhang
miteinander stehen, z.B. Daten eines Feldes oder Puffers, mit einer Basisadressen-Signatur des Feldes und/oder mit einer Speicheradressen-Signatur der jeweiligen Speicherzelle
innerhalb des Feldes, verknüpft werden. Dabei kann jedes Feld seine eigene Speicheradressen-Signatur aufweisen.
Schreibzugriffe, die von dem Programm für einen Puffer ausgeführt werden sollen, aber tatsächlich in den
Speicherbereich eines anderen Puffers schreiben, können zu einer Signatur führen, die für den anderen Puffer nicht erwartetet wird. Dies kann beim Laden der Daten leicht detektiert werden. Somit gewährleistet das obige Verfahren eine hohe Datenintegrität und eignet sich besonders gut für Anwendungen, bei denen Datenintegrität besonders wichtig ist. Selbst wenn ein Angreifer alle Multiplikatoren und Adressen kennen würde, ist die Wahrscheinlichkeit gering, dass der andere, angegriffene Puffer das richtige Codewort aufweist.
In verschiedenen Ausführungsbeispielen kann das Verfahren ein Decodieren eines ersten und zweiten codierten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes, und ein Auswählen des ersten Multiplikators und des zweiten Multiplikators derart, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist, aufweisen.
Weiterhin kann das Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert ein Verschieben der Ziffern des Ergebniswertes der Differenz des codierten ersten und zweiten Zahlenwertes in Richtung der
Ziffernposition mit dem niedrigsten Wert aufweisen, wobei der erste Multiplikator und der zweite Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten Zahlenwertes zu einem decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist.
Beim Decodieren der Daten können nur Subtraktions- und
Verschiebeoperationen, z.B. Bit-Verschiebungen, ausgeführt werden. Dadurch ist obige Codierung besonders effizient und kann weniger rechenintensive Operationen benötigen als
herkömmliche arithmetische Codierungen, z.B. herkömmliche Codierungen mittels AN-, ANB-, oder ANBD-Codes, die zum
Decodieren teure Divisionen verwenden. Gleichzeitig können ähnliche Garantien gewährleistet werden, wie bei einer
herkömmlichen Codierung. Beispielsweise können bei einer redundant ausgeführten Codierung mittels eines AN-Codes mehr Fehler detektiert werden als bei einer herkömmlichen AN- Codierung und gleichzeitig kann aufgrund der besonders
effizienten Decodierung Rechenzeit gespart werden.
Beispielsweise kann eine Diskrepanz oder ein Fehler detektiert werden, wenn bei einer der redundanten Ausführungen eine falsche Operation verwendet wird und bei einer anderen
Ausführung die richtige Operation verwendet wird. Bei der obigen redundant ausgeführten Codierung können ähnlich viele Fehler detektiert werden als bei einer herkömmlichen ANB- Codierung, ohne eine ANB-Codierung zu verwenden. Der erste Multiplikator kann gleich dem zweiten Multiplikator subtrahiert um eine Basiszahl hoch einer Exponentenzahl sein.
Die Basiszahl kann gleich zwei sein und das Verschieben der Ziffern kann ein Bit-Verschieben der Ziffern um die
Exponentenzahl sein.
Unterschiedliche Teile eines Systems, z.B. unterschiedliche Computer-Programme oder unterschiedliche Teile eines Computer- Programms, können mit unterschiedlichen ersten und zweiten Multiplikatoren codiert werden, z.B. derart mit ersten und zweiten Multiplikatoren codiert werden, dass sich jeweils ein anderer Wert der Differenz des ersten und des zweiten
Multiplikators ergibt. Anders ausgedrückt können
unterschiedliche Teile des Systems derart mit ersten und zweiten Multiplikatoren codiert werden, dass sich
unterschiedliche Exponentenzahlen ergeben. Beispielsweise können unterschiedliche Teile des Systems mit ersten und zweiten Multiplikatoren codiert werden, indem unterschiedliche Exponentenzahlen gewählt werden.
Auf diese Weise kann leicht detektiert werden, wenn ein Teil des Systems einen anderen Teil des Systems überschreibt. Ein Decodieren der codierten Daten würde mit hoher
Wahrscheinlichkeit zu falschen decodierten Daten führen, was leicht detektiert werden kann.
In verschiedenen Ausführungsbeispielen kann das Verfahren ein Korrigieren eines fehlerhaften decodierten Zahlenwertes mittels eines codierten ersten und zweiten Zahlenwertes aufweisen, die jeweils dem decodierten Zahlenwert entsprechen.
Somit können Fehler nicht nur detektiert sondern auch
korrigiert werden.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit oder ohne Signaturen sein. Bei einer redundant ausgeführten Codierung mittels eines arithmetischen Codes ohne Signaturen können bei höherer
Performanz ähnliche viele Fehler detektiert werden als bei einer herkömmlichen Codierung mittels eines arithmetischen Codes mit Signaturen. Es können Hardwarefehler detektiert werden, die in Prozessoren, z.B. in der zentralen
Verarbeitungseinheit, und im Speicher, z.B. im
Arbeitsspeicher, auftreten können. Der arithmetische Code kann mindestens einen Code aufweisen aus einer Gruppe von Codes bestehend aus: einem AN-Code, einem ANB-Code, einem AND-Code, einem ANDmem-Code, einem ANBD-Code und einem ANBDmem-Code . In bevorzugten Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
In verschiedenen Ausführungsbeispielen kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, mittels eines Überprüfungs-Schaltkreises durchgeführt werden. Ferner kann das Verfahren ein Übermitteln der ersten codierten ein oder mehreren Ergebniswerte, des ersten Multiplikators, der zweiten codierten ein oder mehreren Ergebniswerte und des zweiten Multiplikators von dem Programm an den Überprüfungs- Schaltkreis aufweisen.
In verschiedenen Ausführungsbeispielen kann das Verfahren mittels eines Überprüfungs-Schaltkreises ausgeführt werden.
Der Überprüfungs-Schaltkreis kann außerhalb des Programms implementiert sein.
Weiterhin kann der Überprüfungs-Schaltkreis in sicherer
Hardware implementiert sein. Der Überprüfungs-Schaltkreis kann auch durch Redundanz abgesichert sein. Ferner kann der Überprüfungs-Schaltkreis durch arithmetische Codes abgesichert sein.
In verschiedenen Ausführungsbeispielen kann ein Verfahren zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer
Ausführung eines Programms ein Fehler aufgetreten ist, ein Erzeugen eines Programm-Code-Abschnittes zum Codieren von ein oder mehreren Operanden mindestens einer Anweisung des
Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator, ein Erzeugen eines Programm-Code-Abschnittes zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte
Zahlenwerte mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator, ein Erzeugen eines Programm-Code- Abschnittes zum Ausführen der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und ein Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten aufweisen. Das Verfahren kann ein
Erzeugen eines Programm-Code-Abschnittes zum Ermitteln
aufweisen, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.
Somit kann der Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, z.B. der codierte Programm-Code, automatisch erzeugt werden.
Alternativ kann der Programm-Code manuell codiert werden, beispielsweise kann der zu schützende und codierte Programm- Code so klein wie möglich gehalten werden und manuell codiert werden . Somit kann ein effizienter Schutz auf Software-Ebene
bereitgestellt werden, der ein Korrumpieren der Daten
verhindern kann. In verschiedenen Ausführungsbeispielen kann das Verfahren ein Erzeugen eines Programm-Code-Abschnittes zum Ermitteln einer ersten Speicheradressen-Signatur basierend auf einer ersten Speicheradresse, ein Erzeugen eines Programm-Code-Abschnittes zum Verknüpfen der ersten codierten ein oder mehreren
Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer ausschließlichen oder (XOR) -Operation und ein Erzeugen eines Programm-Code-Abschnittes zum Speichern der ersten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der ersten Speicheradresse aufweisen. Weiterhin kann das Verfahren ein Erzeugen eines Programm-Code- Abschnittes zum Ermitteln einer zweiten Speicheradressen- Signatur basierend auf einer zweiten Speicheradresse, ein Erzeugen eines Programm-Code-Abschnittes zum Verknüpfen der zweiten codierten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels einer
ausschließlichen oder (XOR) -Operation, und ein Erzeugen eines Programm-Code-Abschnittes zum Speichern der zweiten
verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der zweiten Speicheradresse aufweisen.
In verschiedenen Ausführungsbeispielen kann das Verfahren ein Erzeugen eines Programm-Code-Abschnittes zum Laden der ersten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der ersten Speicheradresse, ein Erzeugen eines Programm-Code- Abschnittes zum Verknüpfen der geladenen ersten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation, ein
Erzeugen eines Programm-Code-Abschnittes zum Laden der zweiten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der zweiten Speicheradresse, und ein Erzeugen eines Programm- Code-Abschnittes zum Verknüpfen der geladenen zweiten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation aufweisen. Weiterhin kann beim Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programm-Codes ein Fehler aufgetreten ist, ein Programm-Code-Abschnitt zum
Ermitteln erzeugt werden, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein Fehler aufgetreten ist, basierend auf den geladenen ersten und zweiten codierten ein oder mehreren Zahlenwerten, dem ersten Multiplikator und dem zweiten Multiplikator.
Der Programm-Code-Abschnitt zum Ermitteln der ersten
Speicheradressen-Signatur kann ferner derart erzeugt werden, dass die erste Speicheradressen-Signatur auf einer ersten Basisspeicheradresse und/oder der ersten Speicheradresse basiert ist, und der Programm-Code-Abschnitt zum Ermitteln der zweiten Speicheradressen-Signatur kann derart erzeugt werden, dass die zweite Speicheradressen-Signatur auf einer zweiten Basisspeicheradresse und/oder der zweiten Speicheradresse basiert ist.
In verschiedenen Ausführungsbeispielen kann das Verfahren ein Erzeugen eines Programm-Code-Abschnittes zum Decodieren eines ersten und zweiten codierten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes und ein Erzeugen des Programm-Code- Abschnittes zum Auswählen des ersten Multiplikators und des zweiten Multiplikators derart, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist, aufweisen.
Ferner kann beim Erzeugen des Programm-Code-Abschnittes zum Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert ein Programm-Code-Abschnitt zum Verschieben der Ziffern des Ergebniswertes der Differenz des codierten ersten und zweiten Zahlenwertes in Richtung der Ziffernposition mit dem niedrigsten Wert erzeugt werden. Der Programm-Code-Abschnitt zum Auswählen des ersten Multiplikators und des zweiten Multiplikators kann derart erzeugt werden, dass der erste Multiplikator und der zweite Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten Zahlenwertes zu einem
decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist.
Weiterhin kann das Verfahren ein Erzeugen eines Programm-Code- Abschnittes zum Korrigieren eines fehlerhaften decodierten Zahlenwertes mittels eines codierten ersten und zweiten
Zahlenwertes aufweisen, die jeweils dem decodierten Zahlenwert entsprechen . In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit oder ohne Signaturen sein.
Der arithmetische Code kann mindestens einen Code aufweisen aus einer Gruppe von Codes bestehend aus: einem AN-Code, einem ANB-Code, einem AND-Code, einem ANDmem-Code, einem ANBD-Code, und einem ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
In verschiedenen Ausführungsbeispielen kann eine
Datenverarbeitungsanordnung zum Ermitteln, ob bei einer
Ausführung eines Programms ein Fehler aufgetreten ist, einen Schaltkreis zum Ausführen von codiertem Programm-Code, einen ersten Anweisung-Ausführungs-Schaltkreis zum Ausführen
mindestens einer Anweisung des codierten Programm-Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind und ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, und einen zweiten Anweisung-Ausführung-Schaltkreis zum Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, aufweisen. Die Datenverarbeitungsvorrichtung kann einen Ermittlungs-Schaltkreis zum Ermitteln aufweisen, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten
Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.
In verschiedenen Ausführungsbeispielen kann die
Datenverarbeitungsanordnung zum Ermitteln, ob bei einer
Ausführung eines Programms ein Fehler aufgetreten ist, einen Empfangs-Schaltkreis zum Empfangen von ersten codierten ein oder mehreren Ergebniswerten, eines ersten Multiplikators, zweiten codierten ein oder mehreren Ergebniswerten und eines zweiten Multiplikators von dem Programm in einem Überprüfungs- Schaltkreis außerhalb des Programms aufweisen. Der erste codierte Ergebniswert kann in dem Programm beim Ausführen zumindest einer Anweisung basierend auf ersten codierten ein oder mehreren Zahlenwerten ermittelt worden sein, wobei die ersten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind. Der zweite codierte Ergebniswert kann in dem Programm beim Ausführen zumindest einer Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten ermittelt worden sein, wobei die zweiten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind. Die Datenverarbeitungsanordnung kann einen Ermittlungs-Schaltkreis aufweisen zum Ermitteln in dem Überprüfungs-Schaltkreis, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf den ersten codierten ein oder mehreren
Ergebniswerten und dem ersten Multiplikator und/oder basierend auf den zweiten ein oder mehreren Ergebniswerten und dem zweiten Multiplikator.
In verschiedenen Ausführungsbeispielen kann die
Datenverarbeitungsanordnung zum Erzeugen von codierten
Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist einen ersten Codierung- Programm-Code-Abschnitt-Erzeugungs-Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Codieren von ein oder mehreren Operanden mindestens einer Anweisung des Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator, einen zweiten Codierung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte Zahlenwerte mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator, einen ersten Anweisung-Ausführung-Programm- Code-Abschnitt-Erzeugungs-Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den ersten codierten ein oder mehreren
Zahlenwerten und einen zweiten Anweisung-Ausführung-Programm- Code-Abschnitt-Erzeugungs-Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren
Zahlenwerten aufweisen. Die Datenverarbeitungsanordnung kann einen Ermittlung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis aufweisen zum Erzeugen eines Programm-Code- Abschnittes zum Ermitteln, ob bei einer Ausführung des
Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten
Multiplikator . In verschiedenen Ausführungsbeispielen kann ein
Computerprogrammelement, wenn es von einem Prozessor
ausgeführt wird, bewirken, dass der Prozessor ein Verfahren zur Datenverarbeitung gemäß einem der obigen
Ausführungsbeispiele ausführt.
Ausführungsbeispiele sind in den Figuren dargestellt und werden im Weiteren näher erläutert.
Figur 1 zeigt ein Flussdiagram, das ein Verfahren zur
Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel illustriert.
Figur 2 zeigt ein Flussdiagram, das ein Verfahren zur
Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem weiteren Ausführungsbeispiel illustriert.
Figur 3 zeigt ein Flussdiagram, das ein Verfahren zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel illustriert.
Figur 4 zeigt eine Datenverarbeitungsanordnung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel.
Figur 5 zeigt eine Datenverarbeitungsanordnung zum Ermitteln, ob in einer Programmausführung ein Fehler aufgetreten ist, gemäß einem weiteren Ausführungsbeispiel.
Figur 6 zeigt eine Datenverarbeitungsanordnung zum Erzeugen von Programm-Code zum Ermitteln, ob in einer Programmausführung ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel. Figur 7 zeigt eine Datenverarbeitungsanordnung gemäß einem Ausführungsbeispiel .
Figur 8 zeigt eine Darstellung gemäß einem
Ausführungsbeispiel, welche das Codieren und Ausführen eines Programms sowie das Decodieren und Überprüfen des codierten Ergebnisses illustriert.
Figur 9 zeigt eine Darstellung gemäß einem
Ausführungsbeispiel, welche einen Speicher mit zwei
Puffern illustriert.
Figur 10 zeigt eine Datenverarbeitungsanordnung gemäß einem
Ausführungsbeispiel .
Fig.l zeigt ein Flussdiagramm 100, das ein Verfahren zur
Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms oder anders ausgedrückt in einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem
Ausführungsbeispiel illustriert.
In 102 kann ein codierter Programm-Code ausgeführt werden. Der codierte Programm-Code kann zumindest einem Code-Abschnitt des auszuführenden Programms entsprechen.
In 104 kann mindestens eine Anweisung des codierten Programm- Codes basierend auf ersten codierten ein oder mehreren
Zahlenwerten ausgeführt werden, die mittels eines
arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind und ein oder mehreren Operanden der mindestens einen Anweisung entsprechen.
In 106 kann die mindestens eine Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten ausgeführt werden, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und ebenfalls den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen In anderen Worten kann die Anweisung dupliziert werden und dabei zuerst auf den ersten codierten ein oder mehreren
Zahlenwerten ausgeführt werden und danach auf den zweiten codierten ein oder mehreren Zahlenwerten ausgeführt werden oder umgekehrt. Die Anweisung kann auch dupliziert werden und parallel auf den ersten und auf den zweiten codierten ein oder mehreren Zahlenwerten ausgeführt werden.
In 108 kann ermittelt werden, ob bei der Ausführung des
Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.
Anschaulich können alle Eingaben und Konstanten, also Daten oder Zahlenwerte, des ursprünglichen Programms in codierte Daten überführt werden. Die ursprünglichen Daten können dabei in gültige Code-Worte überführt werden und auf
Informationsebene kann Redundanz hinzugefügt werden. Die Daten können nicht nur codiert werden, sondern dabei auch dupliziert werden. Alle Anweisungen, die auf diesen Daten ausgeführt werden, können ebenfalls dupliziert werden. Beispielsweise kann die Summe zweier Eingaben als zwei Summen codiert werden, wobei jede Summe auf einer codierten Kopie der Eingaben ausgeführt wird. Alle Anweisungen können auf den codierten Daten ausgeführt werden, ohne die Daten zwischendurch zu decodieren. Beispielsweise kann eine Addition zwei codierte
Zahlenwerte addieren, wobei ein codiertes Ergebnis resultiert, das codiert weiter verarbeitet werden kann. Wenn beim
Ausführen einer Anweisung auf codierten Eingaben ein Fehler auftritt kann das resultierende codierte Ergebnis mit hoher Wahrscheinlichkeit ein ungültiges Codewort sein, was leicht detektiert werden kann. In verschiedenen Ausführungsbeispielen kann jeweils eine
Anweisung des codierten Programm-Codes auf den ersten
codierten ein oder mehreren Zahlenwerten und auf den zweiten codierten ein oder mehreren Zahlenwerten ausgeführt werden. Bevor eine nächste Anweisung des codierten Programm-Codes ausgeführt wird, kann für die ersten und/oder die zweiten Ergebnisse des Ausführens der einen Anweisung ermittelt werden, ob ein Fehler aufgetreten ist. In verschiedenen Ausführungsbeispielen kann nach dem Ausführen von mehreren Anweisungen auf den ersten codierten ein oder mehreren Zahlenwerten und auf den zweiten codierten ein oder mehreren Zahlenwerten ermittelt werden, ob ein Fehler
aufgetreten ist. Es muss also nicht nach jedem duplizierten Ausführen einer Anweisung überprüft werden, ob ein Fehler aufgetreten ist. Dennoch können Fehler, die in mindestens einer beliebigen Anweisung aufgetreten sind, die auf codierten Daten redundant ausgeführt wurde, detektiert werden. In verschiedenen Ausführungsbeispielen kann jeweils wiederholt nach dem Ausführen von ein oder mehreren Anweisungen auf den ersten codierten ein oder mehreren Zahlenwerten und auf den zweiten codierten ein oder mehreren Zahlenwerten ermittelt werden, ob ein Fehler aufgetreten ist. Es können also ein oder mehrere duplizierte Anweisungen ausgeführt werden, dann kann ermittelt werden, ob ein Fehler aufgetreten ist und dann können weitere ein oder mehrere duplizierte Anweisungen ausgeführt werden, für die ermittelt werden kann, ob ein
Fehler aufgetreten ist.
Die ersten bzw. zweiten ein oder mehreren Ergebniswerte des Ausführens einer Anweisung können mit einem ersten bzw.
zweiten akkumulierten Ergebniswert verknüpft werden, z.B.
addiert werden. Der erste bzw. zweite akkumulierte
Ergebniswert kann jeweils gespeichert werden, z.B. in einem ersten bzw. zweiten Akkumulator, z.B. in jeweils einem
Register . Ferner kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, auf dem ersten akkumulierten
Ergebniswert und dem ersten Multiplikator und/oder auf dem zweiten akkumulierten Ergebniswert und dem zweiten
Multiplikator basieren.
Zu Beginn der Programm-Ausführung können das erste und zweite akkumulierte Ergebnis initialisiert werden. Ferner können das erste und zweite akkumulierte Ergebnis initialisiert werden, nachdem ermittelt worden ist, ob ein Fehler aufgetreten ist und bevor weitere erste bzw. zweite codierte ein oder mehrere Ergebniswerte mit dem ersten bzw. zweiten akkumulierten
Ergebniswert verknüpft werden. Die ersten und die zweiten ein oder mehreren Ergebniswerte des Ausführens einer Anweisung können die ersten und die zweiten codierten ein oder mehreren Zahlenwerte für das Ausführen einer anderen Anweisung sein. In diesem Fall können die ersten codierten ein oder mehreren Zahlenwerte der einen und der anderen ersten Anweisung denselben ersten Multiplikator aufweisen und die zweiten codierten ein oder mehreren
Zahlenwerte der einen und der anderen zweiten Anweisung können denselben zweiten Multiplikator aufweisen. Die ersten bzw. zweiten ein oder mehreren Zahlenwerte
verschiedener Anweisungen können jeweils denselben ersten bzw. zweiten Multiplikator aufweisen.
Die ersten bzw. zweiten ein oder mehreren Zahlenwerte
verschiedener Anweisungen können jeweils einen verschiedenen ersten bzw. zweiten Multiplikator aufweisen.
In verschiedenen Ausführungsbeispielen können neben (in anderen Worten parallel zu) , zwischen, vor oder nach dem
Ausführen der ein oder mehreren duplizierten Anweisungen des codierten Programm-Codes auch Anweisungen des Programms ausgeführt werden, die nicht codiert sind. Alle Anweisungen bzw. alle sicherheitskritischen Anweisungen können als duplizierte Anweisungen des codierten Programm- Codes ausgeführt werden. In verschiedenen
Ausführungsbeispielen können alle Anweisungen des codierten Programm-Codes auf codierten Daten ausgeführt werden, ohne die codierten Daten zwischen den Ausführungen zu decodieren oder erneut zu codieren.
Ferner kann eine erste Speicheradressen-Signatur basierend auf einer ersten Speicheradresse ermittelt werden. Eine zweite Speicheradressen-Signatur kann basierend auf einer zweiten Speicheradresse ermittelt werden. Die erste oder die zweite Speicheradressen-Signatur können bekannt sein. Weiterhin können die ersten codierten ein oder mehreren
Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer selbstinversen Operation, z.B. einer ausschließlichen oder (XOR) -Operation, verknüpft werden. Die derart verknüpften ersten codierten ein oder mehreren Zahlenwerte können in einem Speicher an der ersten Speicheradresse gespeichert werden, beispielsweise in einem Register, einem Cache-Speicher oder einem Arbeitsspeicher. Ferner können die zweiten codierten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen- Signatur mittels der selbstinversen Funktion, z.B. der
ausschließlichen oder (XOR) -Operation, verknüpft werden. Auch die derart verknüpften zweiten codierten ein oder mehreren Zahlenwerte können in einem Speicher an der zweiten
Speicheradresse gespeichert werden. Anschaulich können Daten, bevor sie gespeichert werden, mit einer Speicheradressen-Signatur verknüpft werden, die beim Laden der Daten überprüft werden kann.
Die ersten und/oder zweiten ein oder mehreren Ergebniswerte können analog wie oben für die codierten Zahlenwerte
beschrieben gespeichert werden. Ferner können nur die ersten oder nur die zweiten codierten ein oder mehreren Zahlenwerte oder nur die ersten oder nur die zweiten ein oder mehreren Ergebniswerte wie oben beschrieben gespeichert werden.
Weiterhin können nur ein oder mehrere Werte der ersten bzw. der zweiten codierten ein oder mehreren Zahlenwerte oder nur ein oder mehrere Werte der ersten bzw. der zweiten ein oder mehreren Ergebniswerte wie oben beschrieben gespeichert werden.
In verschiedenen Ausführungsbeispielen können die ersten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der ersten Speicheradresse geladen werden. Die geladenen ersten codierten ein oder mehreren Zahlenwerte können mit der ersten Speicheradressen-Signatur mittels einer selbstinversen Funktion, z.B. der ausschließlichen oder (XOR) -Operation, verknüpft werden. Die zweiten codierten ein oder mehreren Zahlenwerte können aus dem Speicher an der zweiten
Speicheradresse geladen werden. Die geladenen zweiten
codierten ein oder mehreren Zahlenwerte können mit der zweiten Speicheradressen-Signatur mittels der selbstinversen Funktion, z.B. der ausschließlichen oder (XOR) -Operation, verknüpft werden .
In verschiedenen Ausführungsbeispielen kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, ferner ein Ermitteln aufweisen, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein
Fehler aufgetreten ist, basierend auf den geladenen ersten und zweiten codierten ein oder mehreren Zahlenwerten, dem ersten Multiplikator und dem zweiten Multiplikator. Ferner können die geladenen ersten bzw. zweiten ein oder mehreren codierten Zahlenwerte mit dem ersten bzw. zweiten akkumulierten
Ergebniswert verknüpft werden, z.B. addiert werden.
Die erste Speicheradressen-Signatur kann auf einer ersten Basisspeicheradresse und/oder der ersten Speicheradresse basiert sein. Die erste Basisspeicheradresse kann einem ersten Speicherbereich eindeutig zugeordnet sein.
Ferner kann die zweite Speicheradressen-Signatur auf einer zweiten Basisspeicheradresse und/oder der zweiten
Speicheradresse basiert sein. Die zweite Basisspeicheradresse kann einem zweiten Speicherbereich eindeutig zugeordnet sein.
Die erste Basisspeicheradresse kann gleich der zweiten
Basisspeicheradresse sein, z.B. wenn die ersten codierten
Zahlenwerte und die zweiten codierten Zahlenwerte in demselben Speicherbereich gespeichert werden.
Weiterhin kann die erste Basisspeicheradresse von der zweiten Basisspeicheradresse verschieden sein, z.B. wenn die ersten codierten Zahlenwerte und die zweiten codierten Zahlenwerte in verschiedenen, logisch voneinander getrennten
Speicherbereichen gespeichert werden. Weitere erste codierte Zahlenwerte können in einem
Speicherbereich gespeichert werden, dem eine weitere erste Basisadresse zugeordnet ist.
Weitere zweite codierte Zahlenwerte können in einem
Speicherbereich gespeichert werden, dem eine weitere zweite Basisadresse zugeordnet ist.
Ferner kann es ein oder mehrere Speicherbereiche geben. Daten, die in einem Zusammenhang miteinander stehen, können in einem Speicherbereich, z.B. einem Feld oder Puffer,
gespeichert werden, indem sie mit einer Basisadressen-Signatur des Feldes und/oder mit einer Speicheradressen-Signatur der jeweiligen Speicherzelle innerhalb des Feldes verknüpft werden.
In verschiedenen Ausführungsbeispielen kann eine
Basisspeicheradresse einen ersten Speicherbereich markieren, beispielsweise die Startadresse eines ersten Puffers
markieren. Eine andere Basisspeicheradresse kann einen zweiten Speicherbereich markieren, beispielsweise die Startadresse eines zweiten Puffers markieren. In dieser Ausführungsform kann, wie später näher beschrieben wird, detektiert werden, wenn codierte ein oder mehrere Zahlenwerte beim Speichern andere codierte ein oder mehrere Zahlenwerte überschreiben oder umgekehrt. Es können jeweils verschiedenen Puffern verschiedene
Basisadressen-Signaturen zugeordnet werden, wobei die
Basisadressen-Signatur auf die Basisadresse des jeweiligen Puffers basiert ist. Das Verknüpfen eines zu speichernden Werts mit der Basisadressen-Signatur mittels einer z.B.
ausschließlichen oder (XOR) -Operation ermöglicht es, zu detektieren, wenn dieser Wert mit dem Wert eines anderen
Puffers oder einem falschen Wert überschrieben wird.
Zusätzlich kann der Wert mit einem Speicheradressen-Wert, basierend auf der Speicheradresse innerhalb des Puffers an welcher der Wert gespeichert werden soll, mittels z.B. der ausschließlichen oder (XOR) -Operation verknüpft werden, zum Detektieren wenn ein oder mehrere Werte eines Puffers an einer falschen Speicheradresse innerhalb des Puffers gespeichert werden .
Ferner können ein erster und ein zweiter codierter Zahlenwert zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes decodiert werden. Der erste Multiplikator und der zweite Multiplikator können derart gewählt werden, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten
Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist. Weiterhin können der erste und der zweite Multiplikator vorbestimmt sein. In verschiedenen Ausführungsbeispielen können der erste und der zweite Multiplikator außerhalb des Programms ermittelt oder ausgewählt werden, beispielsweise in einem Überprüfungs-Schaltkreis. In verschiedenen
Ausführungsbeispielen können der erste und der zweite
Multiplikator beim Compilieren oder beim Interpretieren des Programms ausgewählt oder ermittelt werden.
In verschiedenen Ausführungsbeispielen kann der erste codierte Zahlenwert einen Zahlenwert der ersten codierten ein oder mehreren Zahlenwerte aufweisen und der zweite codierte
Zahlenwert kann einen dem ersten codierten Zahlenwert
entsprechenden Zahlenwert der zweiten codierten ein oder mehreren Zahlenwerte aufweisen.
Es können ein, mehrere oder alle der ersten und der zweiten codierten ein oder mehreren Zahlenwerte decodiert werden.
Es können die ersten und zweiten ein oder mehreren
Ergebniswerte decodiert werden und als nicht codierte ein oder mehrere Zahlenwerte (in anderen Worten Eingabewerte oder
Operanden) für eine nicht codierte Anweisung verwendet werden.
Die ersten und zweiten nicht codierten ein oder mehreren
Ergebniswerte einer nicht codierten Anweisung können zu ersten und zweiten codierten ein oder mehreren Zahlenwerten codiert werden und als codierte erste und zweite ein oder mehrere Zahlenwerte für eine codierte Anweisung verwendet werden.
In verschiedenen Ausführungsbeispielen kann das Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert ferner ein Verschieben der Ziffern des
Ergebniswertes der Differenz des codierten ersten und zweiten Zahlenwertes in Richtung der Ziffernposition mit dem
niedrigsten Wert aufweisen.
Ferner können der erste Multiplikator und der zweite
Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten Zahlenwertes zu einem
decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist. Beim Decodieren von Daten können nur Subtraktions- und Verschiebeoperationen, z.B. Bit- Verschiebungen, ausgeführt werden. Dadurch ist obige Codierung besonders effizient.
Der erste Multiplikator kann gleich dem zweiten Multiplikator subtrahiert um eine Basiszahl hoch einer Exponentenzahl sein.
Ferner kann die Basiszahl gleich der Zahl 2 sein und das Verschieben der Ziffern kann ein Bit-Verschieben der Ziffern um die Exponentenzahl sein.
In verschiedenen Ausführungsbeispielen kann ein fehlerhafter decodierter Zahlenwert mittels eines codierten ersten und zweiten Wertes korrigiert werden, die jeweils dem decodierten Zahlenwert entsprechen.
In verschiedenen Ausführungsbeispielen können ein, mehrere oder alle fehlerhaft decodierten Zahlenwerte, die ein, mehreren oder allen Werten der ersten und zweiten ein oder mehreren codierten und zu decodierenden Zahlenwerten
entsprechen, korrigiert werden.
Weiterhin können ein, mehrere oder alle fehlerhaft decodierten Zahlenwerte, die ein, mehreren oder allen Werten der ersten und zweiten ein oder mehreren zu decodierenden Ergebniswerten entsprechen, korrigiert werden.
Es können die, den fehlerhaften decodierten ein oder mehreren Zahlenwerten entsprechenden, fehlerhaften ersten oder zweiten codierten ein oder mehreren Zahlenwerte korrigiert werden.
Weiterhin können die, den fehlerhaften decodierten ein oder mehreren Zahlenwerten entsprechenden, ersten bzw. zweiten codierten ein oder mehreren Zahlenwerte mittels der zweiten bzw. der ersten codierten ein oder mehreren Zahlenwerte korrigiert werden. In einer Ausgestaltung können die, den fehlerhaften decodierten ein oder mehreren Zahlenwerten entsprechenden, fehlerhaften ersten oder zweiten ein oder mehreren
Ergebniswerte korrigiert werden.
Ferner können die, den fehlerhaften decodierten ein oder mehreren Zahlenwerten entsprechenden, ersten bzw. zweiten codierten ein oder mehreren Ergebniswerte mittels der zweiten bzw. der ersten codierten ein oder mehreren Ergebniswerte korrigiert werden.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit oder ohne Signaturen sein. Der arithmetische Code kann mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem- Code, ein ANBD-Code oder ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
In noch einer Ausgestaltung kann der arithmetische Code jeder beliebige arithmetische Code sein, der das Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte mittels Subtraktion und Bit-Verschieben ermöglicht. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das
Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte ohne Division ermöglicht.
In verschiedenen Ausführungsbeispielen kann das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, mittels eines Überprüfungs-Schaltkreises durchgeführt werden. In verschiedenen Ausführungsbeispielen können die ersten codierten ein oder mehreren Ergebniswerte, der erste
Multiplikator, die zweiten codierten ein oder mehreren
Ergebniswerte und der zweite Multiplikator von dem Programm an den Überprüfungs-Schaltkreis übermittelt werden, zum
Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist. In verschiedenen Ausführungsbeispielen können die ersten codierten ein oder mehreren Ergebniswerte, der erste
Multiplikator, die zweiten codierten ein oder mehreren
Ergebniswerte und der zweite Multiplikator von dem
Überprüfungs-Schaltkreis empfangen werden.
Der Überprüfung-Schaltkreis kann den ersten bzw. zweiten akkumulierten Ergebniswert aufweisen. Die ersten bzw. zweiten empfangenen ein oder mehreren Ergebniswerte können von dem Überprüfungsschaltkreis mit dem ersten bzw. zweiten
akkumulierten Ergebniswert verknüpft werden, z.B. addiert werden .
Ferner können als erste bzw. zweite codierte ein oder mehrere Ergebniswerte der erste bzw. zweite akkumulierte Ergebniswert von dem Programm an den Überprüfungsschaltkreis übermittelt und dort empfangen werden. Der Überprüfungsschaltkreis kann einen ersten bzw. zweiten empfangenen akkumulierten
Ergebniswert mit mindestens einem weiteren ersten bzw. zweiten akkumulierten Ergebniswert verknüpfen, z.B. addieren.
Anschaulich können das Programm oder alternativ der
Überprüfungsschaltkreis den ersten bzw. zweiten akkumulierten Ergebniswert ermitteln. Es können auch beide, das Programm und der Überprüfungsschaltkreis, jeweils einen ersten bzw. zweiten akkumulierten Ergebniswert ermitteln. Beispielsweise kann das Programm Daten nach jeder ausgeführten Anweisung oder erst nach mehreren ausgeführten Anweisungen an den
Überprüfungsschaltkreis übermitteln . In verschiedenen Ausführungsbeispielen kann das Verfahren mittels eines Überprüfungs-Schaltkreises ausgeführt werden. In verschiedenen Ausführungsbeispielen kann der codierte
Programm-Code ein Interpreter-Programm ausweisen, welches das Programm auf sichere Art und Weise lädt, interpretiert und ausführt. Das Interpreter-Programm kann mittels des
Überprüfungs-Schaltkreises ausgeführt werden.
In verschiedenen Ausführungsbeispielen kann der codierte
Programm-Code einen Code aufweisen zum Laden und Überprüfen von Werten, z.B. von gespeicherten Instruktionen, ihren
Operanden und/oder von Ergebniswerten. In dieser
Ausführungsform kann die redundant ausgeführte mindestens eine Anweisung einer Anweisung zum Laden von zu überprüfenden codierten ein oder mehreren Ergebniswerten und/oder dem zugehörigen Multiplikator entsprechen. Die codierten ein oder mehreren Ergebniswerte können den zu ladenden Instruktionen, ihren Operanden oder bereits berechneten Ergebniswerten entsprechen. Die ersten und zweiten codierten ein oder
mehreren Zahlenwerte, die den Operanden der ausgeführten Lade- Anweisung entsprechen, können codierte Speicheradressen aufweisen, an denen die zu ladenden Werte gespeichert sind.
In verschiedenen Ausführungsbeispielen kann der codierte
Programm-Code einen Code aufweisen zum Laden und/oder
Überprüfen von Werten, z.B. von gespeicherten oder
übermittelten Instruktionen und ihren Operanden, und einen Code aufweisen zum Ausführen der geladenen Instruktionen basierend auf ihren Operanden.
Der Überprüfungs-Schaltkreis kann außerhalb des Programms implementiert sein.
Ferner kann der Überprüfungs-Schaltkreis das Ermitteln
ausführen, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
In verschiedenen Ausführungsbeispielen kann der Überprüfungs- Schaltkreis in sicherer Hardware implementiert sein. Der Überprüfungs-Schaltkreis kann in Software implementiert sein. Der Überprüfungs-Schaltkreis kann als codierter
Programm-Code implementiert sein. Ferner kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
In verschiedenen Ausführungsbeispielen kann der Überprüfungs- Schaltkreis durch arithmetische Codes abgesichert sein.
Fig.2 zeigt ein Flussdiagramm 200, das ein Verfahren zur
Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem
Ausführungsbeispiel illustriert.
In 202 können erste codierte ein oder mehrere Ergebniswerte, ein erster Multiplikator, zweite codierte ein oder mehrere Ergebniswerte und ein zweiter Multiplikator von dem Programm in einem Überprüfungs-Schaltkreis empfangen werden.
Der erste codierte Ergebniswert kann in dem Programm beim Ausführen zumindest einer Anweisung basierend auf ersten codierten ein oder mehreren Zahlenwerten ermittelt worden sein, wobei die ersten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sein können.
Der zweite codierte Ergebniswert kann in dem Programm beim Ausführen zumindest einer Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten ermittelt worden sein, wobei die zweiten codierten ein oder mehreren
Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sein können.
In 204 kann in dem Überprüfungs-Schaltkreis ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf den ersten codierten ein oder mehreren Ergebniswerten und dem ersten Multiplikator und/oder basierend auf den zweiten ein oder mehreren Ergebniswerten und dem zweiten Multiplikator.
In verschiedenen Ausführungsbeispielen kann der Überprüfungs- Schaltkreis außerhalb des Programms implementiert sein.
Anschaulich sendet ein Programm, dessen Anweisungen oder
Berechnungen auf Fehler hin überprüft werden sollen, codierte Werte an den Überprüfungs-Schaltkreis oder speichert die codierten Werte in einem gemeinsamen Speicher. Der
Überprüfungs-Schaltkreis überprüft die Werte, um zu ermitteln, ob bei einer Ausführung des Programms ein Fehler aufgetreten ist. Dabei sind die Parameter, mit denen die Werte codiert sind dem Überprüfungs-Schaltkreis bekannt oder werden
alternativ ebenfalls an den Überprüfungs-Schaltkreis
übertragen . In verschiedenen Ausführungsbeispielen können erste ein oder mehrere Zahlenwerte aus dem Speicher an einer ersten
Speicheradresse geladen werden und eine erste
Speicheradressen-Signatur basierend auf der ersten
Speicheradresse ermittelt werden. Die geladenen ersten ein oder mehreren Zahlenwerte können mit der ersten
Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation verknüpft werden. Weiterhin können zweite ein oder mehrere Zahlenwerte aus dem Speicher an einer zweiten Speicheradresse geladen werden, eine zweite Speicheradressen- Signatur basierend auf der zweiten Speicheradresse ermittelt werden und die geladenen zweiten ein oder mehreren Zahlenwerte können mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation verknüpft werden. Die geladenen ersten ein oder mehreren Zahlenwerte können die ersten codierten ein oder mehreren Ergebniswerte und den ersten Multiplikator aufweisen und die zweiten ein oder mehreren Zahlenwerte können die zweiten codierten ein oder mehreren Ergebniswerte und den zweiten Multiplikator
aufweisen .
Das Empfangen der ersten codierten ein oder mehreren
Ergebniswerte, des ersten Multiplikators, der zweiten
codierten ein oder mehreren Ergebniswerte und des zweiten Multiplikators können das Laden der ersten und zweiten
Zahlenwerte aufweisen. Ferner kann in dem Überprüfungs-Schaltkreis ermittelt werden, ob beim Empfangen der Werte in dem Überprüfungs-Schaltkreis ein Fehler aufgetreten ist, basierend auf den geladenen ersten und zweiten Zahlenwerten. Der Überprüfung-Schaltkreis kann einen ersten bzw. zweiten akkumulierten Ergebniswert aufweisen, z.B. einen ersten bzw. zweiten Akkumulator, z.B. jeweils ein Register, und
eingerichtet sein, die ersten bzw. die zweiten codierten ein oder mehreren Ergebniswerte mit dem ersten bzw. zweiten akkumulierten Ergebniswert zu verknüpfen, z.B. zu addieren.
Weiterhin kann der Überprüfungs-Schaltkreis eingerichtet sein, das erste bzw. zweite akkumulierte Ergebnis zu initialisieren, z.B. nachdem ermittelt worden ist, ob ein Fehler aufgetreten ist und bevor weitere erste bzw. zweite codierte ein oder mehrere Ergebniswerte mit dem ersten bzw. zweiten
akkumulierten Ergebniswert verknüpft werden.
In dem Überprüfungs-Schaltkreis kann ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf dem ersten akkumulierten Ergebniswert und dem ersten Multiplikator und/oder basierend auf dem zweiten akkumulierten Ergebniswert und dem zweiten Multiplikator.
In einer Ausgestaltung können die ersten und zweiten codierten ein oder mehreren Ergebniswerte zu decodierten ein oder mehreren Ergebniswerten mittels einer Differenz der ersten und zweiten codierten ein oder mehreren Ergebniswerte decodiert werden. Der erste Multiplikator und der zweite Multiplikator können derart gewählt werden, dass ein Decodieren des
codierten ersten und zweiten Ergebniswertes zu einem
decodierten Ergebniswert mittels einer Differenz des codierten ersten und zweiten Ergebniswertes möglich ist.
Ferner können die ersten und/oder zweiten decodierten ein oder mehreren Ergebniswerte an eine Ausgabeeinheit übermittelt werden . Es können fehlerhafte decodierte ein oder mehrere
Ergebniswerte mittels erster und zweiter codierter ein oder mehrerer Ergebniswerte, die jeweils den decodierten ein oder mehreren Ergebniswerten entsprechen, korrigiert werden. Weiterhin können die, den fehlerhaften decodierten ein oder mehreren Ergebniswerte entsprechenden, fehlerhaften ersten oder zweiten codierten ein oder mehreren Ergebniswerte
korrigiert werden. Die, den fehlerhaften decodierten ein oder mehreren
Ergebniswerte entsprechenden, ersten bzw. zweiten codierten ein oder mehreren Ergebniswerte können mittels der zweiten bzw. der ersten codierten ein oder mehreren Ergebniswerte korrigiert werden.
Weiterhin können die korrigierten ersten oder zweiten
codierten ein oder mehreren Ergebniswerte an das Programm oder eine Ausgabeeinheit übermittelt werden. Das Übermitteln kann aufweisen, die ersten und/oder die zweiten codierten ein oder mehreren Ergebniswerte jeweils mit der ersten oder zweiten Speicheradressen-Signatur mittels einer ausschließlichen oder (XOR) -Operation zu verknüpfen und die ersten und/oder die zweiten codierten ein oder mehreren Ergebniswerte in einem Speicher an jeweils der ersten oder der zweiten Speicheradresse zu speichern. Der arithmetische Code kann ein arithmetischer Code mit oder ohne Signaturen sein.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem-Code, ein ANBD-Code oder ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das
Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte mittels Subtraktion und Bit-Verschieben
ermöglicht. In verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte ohne Division ermöglicht.
Der Überprüfungs-Schaltkreis kann in sicherer Hardware
implementiert sein.
Ferner kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
Auch kann der Überprüfungs-Schaltkreis durch arithmetische Codes abgesichert sein.
Fig.3 zeigt ein Flussdiagramm 300, das ein Verfahren zum
Erzeugen von Programm-Code, ob bei einer Ausführung eines Programms oder anders ausgedrückt in einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem
Ausführungsbeispiel illustriert.
In 302 kann ein Programm-Code-Abschnitt zum Codieren von ein oder mehreren Operanden mindestens einer Anweisung des
Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator erzeugt werden.
In 304 kann ein Programm-Code-Abschnitt zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte Zahlenwerte mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator erzeugt werden.
Während des Erzeugens des Programm-Code-Abschnittes können codierte Konstanten vollständig aus nicht kodierten konstanten Operanden berechnet werden, die ausschließlich konstante Werte (in anderen Worten Werte, die zum Zeitpunkt des Erzeugens bekannt sind) aufweisen.
Ferner können während des Erzeugens des Programm-Code- Abschnittes Terme, die Variablen aufweisen, deren Wert zum Zeitpunkt des Erzeugens nicht bekannt ist, in codierte Terme überführt werden.
In 306 kann ein Programm-Code-Abschnitt zum Ausführen der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten erzeugt werden. In 308 kann ein Programm-Code-Abschnitt zum Ausführen der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten erzeugt werden.
In 310 kann ein Programm-Code-Abschnitt zum Ermitteln erzeugt werden, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren
Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Anschaulich kann Programm-Code zum Ermitteln, ob ein Fehler auftritt, wenn dieser Programm-Code ausgeführt wird,
automatisch erzeugt werden. Somit kann ein effizienter
automatischer Schutz für Computer-Programme bereitgestellt werden, z.B. für ein ganzes Computerprogramm oder besonders sicherheitskritische Teilbereiche eines Programms, ohne dass Programm-Code manuell geändert oder eingefügt werden muss.
In verschiedenen Ausführungsbeispielen können beim Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der
Ausführung des Programm-Codes ein Fehler aufgetreten ist, ein erster und ein zweiter akkumulierter Ergebniswert zum
Ermitteln, ob bei der Ausführung des Programm-Codes ein Fehler aufgetreten ist, verwendet werden. Das Ermitteln, ob ein
Fehler aufgetreten ist, kann auf dem ersten akkumulierten
Ergebniswert und dem ersten Multiplikator und/oder basierend auf dem zweiten akkumulierten Ergebniswert und dem zweiten Multiplikator basieren. In verschiedenen Ausführungsbeispielen kann ein Programm-Code- Abschnitt erzeugt werden, zum Verknüpfen, z.B. zum Addieren, der ersten bzw. zweiten codierten ein oder mehreren
Ergebniswerten mit dem ersten bzw. zweiten akkumulierten
Ergebnis. Ferner kann ein Programm-Code-Abschnitt erzeugt werden, zum Initialisieren des ersten bzw. zweiten
akkumulierten Ergebnisses, z.B. zu Beginn der Programm- Ausführung und/oder nach einem Ermitteln, ob ein Fehler aufgetreten ist, bevor nächste ein oder mehrere Ergebniswerte mit dem jeweiligen akkumulierten Ergebnis verknüpft werden.
Ferner können ein Programm-Code-Abschnitt zum Ermitteln einer ersten Speicheradressen-Signatur basierend auf einer ersten Speicheradresse, ein Programm-Code-Abschnitt zum Verknüpfen der ersten codierten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer
ausschließlichen oder (XOR) -Operation und ein Programm-Code- Abschnitt zum Speichern der ersten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der ersten Speicheradresse erzeugt werden.
Es können ein Programm-Code-Abschnitt zum Ermitteln einer zweiten Speicheradressen-Signatur basierend auf einer zweiten Speicheradresse, ein Programm-Code-Abschnitt zum Verknüpfen der zweiten codierten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels einer
ausschließlichen oder (XOR) -Operation und ein Programm-Code- Abschnitt zum Speichern der zweiten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der zweiten Speicheradresse erzeugt werden.
Ferner können ein Programm-Code-Abschnitt zum Laden der ersten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der ersten Speicheradresse und ein Programm-Code-Abschnitt zum Verknüpfen der geladenen ersten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels der
ausschließlichen oder (XOR) -Operation erzeugt werden.
Es können ein Programm-Code-Abschnitt zum Laden der zweiten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der zweiten Speicheradresse und ein Programm-Code-Abschnitt zum Verknüpfen der geladenen zweiten ein oder mehreren
Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation erzeugt werden.
In verschiedenen Ausführungsbeispielen kann beim Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programm-Codes ein Fehler aufgetreten ist, ferner ein Programm-Code-Abschnitt zum Ermitteln erzeugt werden, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein Fehler aufgetreten ist,
basierend auf den geladenen ersten und zweiten codierten ein oder mehreren Zahlenwerten, dem ersten Multiplikator und dem zweiten Multiplikator. Ferner kann ein Programm-Code-Abschnitt erzeugt werden, zum Verknüpfen der geladenen ersten bzw. zweiten codierten ein oder mehreren Zahlenwerten mit dem ersten bzw. zweiten akkumulierten Ergebniswert.
In einer Ausgestaltung kann der Programm-Code-Abschnitt zum Ermitteln der ersten Speicheradressen-Signatur derart erzeugt werden, dass die erste Speicheradressen-Signatur auf einer ersten Basisspeicheradresse und/oder der ersten
Speicheradresse basiert ist. Der Programm-Code-Abschnitt zum Ermitteln der zweiten Speicheradressen-Signatur kann derart erzeugt werden, dass die zweite Speicheradressen-Signatur auf einer zweiten Basisspeicheradresse und/oder der zweiten
Speicheradresse basiert ist.
Ein Programm-Code-Abschnitt zum Decodieren eines ersten und zweiten codierten Zahlenwertes kann zu einem decodierten
Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes erzeugt werden. Der Programm-Code- Abschnitt zum Auswählen des ersten Multiplikators und des zweiten Multiplikators kann derart erzeugt werden, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist.
Ferner kann beim Erzeugen des Programm-Code-Abschnittes zum Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert ferner ein Programm-Code- Abschnitt zum Verschieben der Ziffern des Ergebniswertes der Differenz des codierten ersten und zweiten Zahlenwertes in Richtung der Ziffernposition mit dem niedrigsten Wert erzeugt werden. Der Programm-Code-Abschnitt zum Auswählen des ersten Multiplikators und des zweiten Multiplikators kann derart erzeugt werden, dass der erste Multiplikator und der zweite Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten Zahlenwertes zu einem
decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist. Der Programm-Code-Abschnitt zum Auswählen des ersten
Multiplikators und des zweiten Multiplikators kann derart erzeugt werden, dass der erste Multiplikator gleich dem zweiten Multiplikator subtrahiert um eine Basiszahl hoch einer Exponentenzahl ist.
In einer Ausgestaltung kann der Programm-Code-Abschnitt zum Auswählen des ersten Multiplikators und des zweiten
Multiplikators derart erzeugt werden, dass die Basiszahl gleich der Zahl 2 ist und das Verschieben der Ziffern ein Bit- Verschieben der Ziffern um die Exponentenzahl ist.
Ferner kann ein Programm-Code-Abschnitt zum Korrigieren eines fehlerhaften decodierten Zahlenwertes mittels eines codierten ersten und zweiten Wertes erzeugt werden, die jeweils dem decodierten Zahlenwert entsprechen.
Der arithmetische Code kann ein arithmetischer Code mit oder ohne Signaturen sein.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem-Code, ein ANBD-Code oder ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
Fig.4 zeigt eine Datenverarbeitungsanordnung 400 zum
Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, die einen Schaltkreis 402 zum Ausführen von codiertem Programm-Code, einen ersten Anweisung-Ausführungs- Schaltkreis 404 zum Ausführen mindestens einer Anweisung des codierten Programm-Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind und ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, und einen zweiten Anweisung-Ausführung- Schaltkreis 406 zum Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen, aufweist. Ferner weist die Datenverarbeitungsanordnung 400 einen Ermittlungs-Schaltkreis 408 auf zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten
Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Der Schaltkreis 402, der erste Anweisung-Ausführungs-Schaltkreis 404, der zweite Anweisung- Ausführungs-Schaltkreis 406 und der Ermittlungs- Schaltkreis 408 können über eine Verbindung 410,
beispielsweise einer Leitung, einer Mehrzahl von separaten Leitungen, einem Bus, oder mittels einer drahtlosen Verbindung miteinander kommunizieren und Informationen austauschen.
Anschaulich kann die Datenverarbeitungsanordnung 400 eine Anordnung sein zum Ausführen eines Programms, das auf Fehler überprüft oder überwacht werden soll.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code ohne Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das
Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte mittels Subtraktion und Bit-Verschieben
ermöglicht. In verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte ohne Division ermöglicht. In verschiedenen Ausführungsbeispielen kann der arithmetische Code mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem-Code, ein ANBD-Code, oder ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
Fig. 5 zeigt eine Datenverarbeitungsanordnung 500 zum
Ermitteln, ob bei (oder: ob in) einer Ausführung eines
Programms ein Fehler aufgetreten ist, die einen Empfangs- Schaltkreis 502 aufweist zum Empfangen von ersten codierten ein oder mehreren Ergebniswerten, eines ersten Multiplikators, zweiten codierten ein oder mehreren Ergebniswerten und eines zweiten Multiplikators von dem Programm in einem Überprüfungs- Schaltkreis, wobei der erste codierte Ergebniswert in dem
Programm beim Ausführen zumindest einer Anweisung basierend auf ersten codierten ein oder mehreren Zahlenwerten ermittelt worden ist, wobei die ersten codierten ein oder mehreren
Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind, und wobei der zweite codierte Ergebniswert in dem Programm beim
Ausführen zumindest einer Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten ermittelt worden ist, wobei die zweiten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung
entsprechen und mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind. Ferner weist die Datenverarbeitungsanordnung 500 einen Ermittlungs-Schaltkreis 504 auf zum Ermitteln in dem Überprüfungs-Schaltkreis, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf den ersten codierten ein oder mehreren
Ergebniswerten und dem ersten Multiplikator und/oder basierend auf den zweiten ein oder mehreren Ergebniswerten und dem zweiten Multiplikator. Der Empfangs-Schaltkreis 502 und der Ermittlungs-Schaltkreis 504 können über eine Verbindung 506, beispielsweise einem Draht, einer Mehrzahl von separaten Drähten, einem Bus, oder mittels einer drahtlosen Verbindung miteinander kommunizieren und Informationen austauschen.
In verschiedenen Ausführungsformen kann der Überprüfungs- Schaltkreis außerhalb des Programms implementiert sein.
Anschaulich kann die Datenverarbeitungsanordnung 500 eine Anordnung sein zum Ausführen eines Programms, das auf Fehler überprüft oder überwacht werden soll.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code ohne Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das
Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte mittels Subtraktion und Bit-Verschieben
ermöglicht. In verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte ohne Division ermöglicht.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem-Code, ein ANBD-Code, oder ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
Fig.6 zeigt eine Datenverarbeitungsanordnung 600 zum Erzeugen von codierten Programm-Code zum Ermitteln, ob bei einer
Ausführung eines Programms ein Fehler aufgetreten ist, die einen ersten Codierung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis 602 zum Erzeugen eines Programm-Code-Abschnittes zum Codieren von ein oder mehreren Operanden mindestens einer Anweisung des Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator und einen zweiten Codierung- Programm-Code-Abschnitt-Erzeugungs-Schaltkreis 604 zum
Erzeugen eines Programm-Code-Abschnittes zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte Zahlenwerte mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator aufweist. Ferner weist die Datenverarbeitungsanordnung 600 einen ersten Anweisung-Ausführung-Programm-Code-Abschnitt- Erzeugungs-Schaltkreis 606 zum Erzeugen eines Programm-Code- Abschnittes zum Ausführen der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und einen zweiten Anweisung-Ausführung-Programm-Code-Abschnitt- Erzeugungs-Schaltkreis 608 zum Erzeugen eines Programm-Code- Abschnittes zum Ausführen der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und einen Ermittlung-Programm-Code-Abschnitt-Erzeugungs-Schaltkreis 610 auf zum Erzeugen eines Programm-Code-Abschnittes zum
Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Der erste
Codierung-Programm-Code-Abschnitt-Erzeugungs-Schaltkreis 602 , der zweite Codierung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis 604, der erste Anweisung-Ausführung-Programm-Code- Abschnitt-Erzeugungs-Schaltkreis 606, der zweite Anweisung- Ausführung-Programm-Code-Abschnitt-Erzeugungs-Schaltkreis 608 und der Ermittlung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis 610 können über eine Verbindung 612,
beispielsweise einem Draht, einer Mehrzahl von separaten
Drähten, einem Bus, oder mittels einer drahtlosen Verbindung miteinander kommunizieren und Informationen austauschen.
Anschaulich kann die Datenverarbeitungsanordnung 600 ein
Compiler oder ein Interpreter zum Erzeugen eines Programm- Codes sein, der von einer Datenverarbeitung zur Ausführung eines Programms ausgeführt werden kann.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code mit Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code ein arithmetischer Code ohne Signaturen sein. In
verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das
Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte mittels Subtraktion und Bit-Verschieben
ermöglicht. In verschiedenen Ausführungsbeispielen kann der arithmetische Code jeder beliebige arithmetische Code sein, der das Decodieren der ersten und zweiten codierten ein oder mehreren Zahlenwerte ohne Division ermöglicht.
In verschiedenen Ausführungsbeispielen kann der arithmetische Code mindestens einen der folgenden Codes enthalten oder mindestens einer der folgenden Codes sein: ein AN-Code, ein ANB-Code, ein AND-Code, ein ANDmem-Code, ein ANBD-Code und ein ANBDmem-Code . In vorteilhaften Ausführungsbeispielen weist der arithmetische Code den AN-Code auf.
Es kann ein Compu
das, wenn es von
dass der Prozesso
200, 300 zur Date
Gemäß verschiedenen Ausführungsformen können
Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden für die automatische Überwachung eines Programmablaufs von durch arithmetische Codes mit oder ohne Signaturen
geschützten Programmen zur frühzeitigen Erkennung von
fehlerhaften Abweichungen im Datenfluss des Programms.
Gemäß verschiedenen Ausführungsformen können
Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden für arithmetische Codes, funktionale Sicherheit,
Software-Fehlerdetektion, und Datenfluss-Überprüfung .
Gemäß verschiedenen Ausführungsformen können
Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden zum Verwenden von zur Laufzeit des Programms durch codierte Ausführung erzeugten codierten Zahlenwerten bzw.
codierten Ergebniswerten. Die erzeugten codierten
Ergebniswerte können dabei unauflösbar vom Kontroll- und
Datenfluss der durch den arithmetischen Code mit oder ohne Signaturen geschützten Ausführung des Programms abhängen.
Gemäß verschiedenen Ausführungsformen kann die Frequenz des Überprüfens der codierten Zahlen- oder Ergebniswerte von „nach jeder Instruktion" bis „vor der Ausgabe" angepasst werden, so dass Fehler erkannt werden können ehe eine fehlerhafte Ausgabe extern sichtbar wird.
Die Werte, die zur codierten Ausführung benötigt werden, z.B. die Parameter der Codierungsfunktion bzw. des arithmetischen Codes, können statisch während des Transformationsprozesses erzeugt werden und vom Programm völlig unabhängige, zufällig wählbare Werte beliebiger Größe und/oder Anzahl sein, so dass eine zufällige Erzeugung dieser Werte trotz transienter oder permanenter Fehler während der Ausführung des Programms mit beliebiger Wahrscheinlichkeit ausgeschlossen werden kann.
Der zu schützende Quellcode des Programms kann vor der
eigentlichen Ausführung in eine semantisch identische aber geschützte Version transformiert werden. Deren korrekte
Abarbeitung kann dann zur Laufzeit beispielsweise durch einen sicheren Watchdog-Prozess , z.B. außerhalb des Programms, oder mittels spezieller sicherer Anweisungen, z.B. innerhalb des Programms, überprüft werden.
Gemäß verschiedenen Ausführungsformen kann der
Transformationsprozess sicherstellen, dass nachdem dieser abgeschlossen ist, mittels des Watchdog-Prozesses oder mittels spezieller, sicherer Anweisungen erkannt werden kann, wenn die spätere Ausführung des Programms von der durch den
Programmierer festgelegten Ablaufbeschreibung abweicht.
Gemäß verschiedenen Ausführungsformen können nur wenig
zusätzliche CPU-Zyklen und Programmspeicher benötigt werden.
Gemäß verschiedenen Ausführungsformen kann das durch den
Software-Codier-Compiler erzeugte, geschützte Programm direkt auf unsicherer Hardware ausgeführt werden.
Somit kann der Umfang des Schutzes durch den Anwender flexibel bestimmt werden.
Gemäß verschiedenen Ausführungsformen können Ausgaben an beliebigen Punkten im Programmablauf erlaubt werden.
Gemäß verschiedenen Ausführungsformen kann die Implementierung von „fail-fast" Verhalten in Programmen ermöglicht werden, das heißt Fehler können so schnell wie möglich erkannt werden, bereitgestellt werden, was eine frühzeitige Reaktion erlauben kann .
Gemäß verschiedenen Ausführungsformen kann flexibel der
Datenfluss bei der Ausführung des Programms mit einer
bestimmten mathematisch nachweisbaren Wahrscheinlichkeit geschützt werden.
Es können mehrere geschützte und ungeschützte Programme auf einem Rechner parallel laufen.
Ausführungsformen können in sicherheitsrelevanten Anwendungen, beispielsweise in der Automobiltechnik, der Flugzeugtechnik oder der Medizintechnik eingesetzt werden. Ausführungsformen können Datenintegrität und große sichere Verfügbarkeit von Daten gewährleisten, welches in verschiedenen Gebieten von größter Bedeutung ist, z.B. bei sicherheitsrelevanten oder - kritischen Anwendungen bis hin zu kommerziellen Web (Netz)- Diensten .
FIG.7 zeigt eine Datenverarbeitungsanordnung 700 gemäß einem Ausführungsbeispiel. Die Datenverarbeitungsanordnung 700 kann eingesetzt werden als eine oder mehrere der oben genannten Datenverarbeitungsanordnungen (beispielsweise wie in FIG. 4 bis FIG. 6 beschrieben). Die Datenverarbeitungsanordnung 700 kann enthalten Speichermedien 702, die ein Programm 710 oder mehrere Programme sowie Eingabedaten 712 enthalten können. Das Programm 710 kann ein Programm sein, dass eines der oben genannten Verfahren ausführen kann, beispielsweise eine
Compilierung, einen Programmablauf, der auf Fehler überwacht werden soll, oder einen Programmablauf, der Fehler bei einer Ausführung eines anderen Programms überwacht. Die Eingabedaten 712 können dabei im Falle des Compilierens den Quell-Code des zu compilierenden Programms enthalten. Ferner kann die
Datenverarbeitungsanordnung 700 einen Arbeitsspeicher 704 enthalten, in dem Daten 714 enthalten sein können. Die Daten 714 können Daten eines momentan ausgeführten Programms
beinhalten. Ferner kann die Datenverarbeitungsanordnung 700 eine zentrale Verarbeitungseinheit 706 (engl.: „Central
Processing Unit", CPU) enthalten, die die Verarbeitung steuert und ausführt. Ferner kann die Datenverarbeitungsanordnung 700 gesicherte Spezialhardware 708 enthalten. Beispielsweise können der Überprüfungs-Schaltkreis oder die sicheren
speziellen Anweisungen zur Überprüfung in der gesicherten Spezialhardware 708 bereitgestellt werden, die gesichert fehlerfrei arbeitet. Die beschriebenen Komponenten der
Datenverarbeitungsanordnung 700 können mit einer Verbindung
716, beispielsweise einem Draht, einer Mehrzahl von separaten Drähten, einem Bus, oder mittels einer drahtlosen Verbindung miteinander kommunizieren und Informationen austauschen. Gemäß verschiedenen Ausführungsformen wird ein Codier-Compiler (englisch: „Encoding Compiler") bereitgestellt, der
automatisch mindestens zweifach AN-, ANB- und/oder ANBD-Code auf eine Anwendung anwendet, um mindestens zwei codierte
Anweisungen zu erhalten.
Gemäß verschiedenen Ausführungsformen werden
Datenverarbeitungsanordnungen und Verfahren zum zweifachen oder mehrfachen AN-, ANB-, ANBDmem-Codieren, um mindestens zwei codierte Anweisungen zu erhalten bzw. auszuführen, und zum Ermitteln von Hardware-Fehlern in Software bereitgestellt
Gemäß Ausführungsformen wird die Möglichkeit zur Überwachung des Programmablaufs von mit arithmetischen Codes mit oder ohn Signaturen geschützten Programmen geschaffen, um zu erkennen, wenn die Ausführung des Programms von der durch den
Programmierer festgelegten Ablaufbeschreibung abweicht.
Gemäß verschiedenen Ausführungsformen können Abweichungen im Datenfluss des Programms frühzeitig während der Ausführung des Programms mit einer bestimmten Wahrscheinlichkeit erkannt werden .
Gemäß Ausführungsformen wird die Möglichkeit geschaffen, Daten verknüpft mit einer Speicheradressen-Signatur redundant zu speichern, um ein unerlaubtes Lesen und Auswerten dieser Daten zu verhindern. Gemäß Ausführungsformen wird die Möglichkeit zur Überwachung von aus einem Speicher gelesenen Daten
geschaffen, um zu erkennen, wenn die Ausführung des Programms von der durch den Programmierer festgelegten
Ablaufbeschreibung abweicht.
Durch Erkennen dieser Fehler können andernfalls willkürlich ausfallende Systeme in einen sicheren Zustand (englisch: fail- safe) überführt und entsprechende Fehlerbehandlungsmaßnahmen angestoßen werden, z.B. der Versuch einer Fehlerkorrektur oder einer erneuten Ausführung. Gemäß Ausführungsformen werden neue Konzepte optimistischer Programmausführung (englisch: Trial and Error) und Sicherheitsmaßnahmen bereitgestellt. Gemäß verschiedenen Ausführungsformen kann ein Fehler- Erkennungs-Ansatz bereitgestellt werden basierend auf
redundant eingesetzten arithmetischen Codes, die Ende-zu-Ende- Software-implementierte Hardware-Fehler-Erkennung unterstützt, d.h. er kann Daten schützen vor unerkannten Fehlern während des Speicherns, des Transports und Berechnungen. Seine Fehler- Erkennungs-Möglichkeiten können entkoppelt sein von der eingesetzten Hardware. Gemäß verschiedenen Ausführungsformen kann ein Fehler- Erkennungs-Ansatz bereitgestellt werden basierend auf
redundant eingesetzten arithmetischen Codes, der ein
effizientes Decodieren und ein effizientes Überprüfen
ermöglicht, ob ein Fehler aufgetreten ist.
Gemäß verschiedenen Ausführungsbeispielen kann die Anzahl von SDCs für zweifach (oder mehrfach) AN-codierte Programme verglichen mit AN-codierten Programmen reduziert werden. Gemäß Ausführungsbeispielen können mittels Verknüpfens von AN- codierten Daten mit einer Speicheradressen-Signatur zusätzlich Fehler von ausgetauschten Operanden detektiert werden.
Gemäß Ausführungsbeispielen können arithmetische Codes eine Technik zum Erkennen von Hardware-Fehlern zur Laufzeit sein. Das Codieren kann Redundanz zu allen Daten-Wörtern hinzufügen. Gültige Code-Wörter können nur eine kleine Teilmenge aller möglichen Daten-Wörter sein. Dabei kann die Menge aller möglichen Datenwörter die Menge aller darstellbaren Daten einer bestimmten Größe sein, und die Menge der Code-Wörter kann die Untermenge aller möglichen Datenwörter erzeugt durch einen Code sein.
Korrekt ausgeführte arithmetische Operationen können den Code erhalten, d.h. mit einem gültigen Code-Wort als Eingabe kann die Ausgabe auch ein gültiges Code-Wort sein. Eine fehlerhafte arithmetische Operation oder eine mit nicht-codierten Wörtern aufgerufene Operation kann mit hoher Wahrscheinlichkeit ein Ergebnis produzieren, welches ein ungültiges Code-Wort ist. Gemäß verschiedenen Ausführungsformen kann, wenn eine
Anwendung unter Verwendung arithmetischer Codes codiert ist, sie nur codierte Daten verarbeiten, d.h. es kann gewünscht sein, dass alle Eingaben codiert werden, und alle Berechnungen können codierte Daten verwenden und produzieren. Daher kann es gewünscht sein, nur Operationen zu verwenden, die den Code im fehlerfreien Fall erhalten. Für einen AN-Code kann die codierte Version von xc einer
Variable x erhalten werden durch Multiplizieren ihres
ursprünglichen Funktionswertes xf mit einem konstanten
Multiplikator A. Um den Code zu überprüfen, kann der Rest von xc bei Teilung durch A (welcher „xc Modulus A" genannt werden kann) berechnet werden, welcher Null für ein gültiges Code- Wort sein sollte.
Ein AN-Code kann fehlerhafte Operationen detektieren, d.h. unkorrekt ausgeführte Operationen, und modifizierte Operanden, also beispielsweise Daten, die von einem Bit-Fehler,
beispielsweise einem Bit-Flip (also ein falscher Wert in einem Bit) getroffen wurden. Diese Fehler können detektiert werden, weil sie zu Daten führen, die mit hoher Wahrscheinlichkeit nicht ein Vielfaches von A sind. Die Wahrscheinlichkeit, dass solch ein Fehler zu einem gültigen Code führt, kann in etwa 1/A sein. Trotzdem kann, wenn ein Bit Flip auf dem
(uncodierten) Adress-Bus passiert, auf ein falsches Speicher- Wort zugegriffen werden, das mit hoher Wahrscheinlichkeit auch ein Vielfaches von A enthält. Daher kann der so-genannte „ausgetauschte Operand" nicht mit einem AN-Code detektiert werden, weil der Fehler auch ein Vielfaches von A ist. Ein Bit-Flip in der Instruktions-Einheit einer CPU kann das
Ausführen einer falschen Operation (sogenannte „ausgetauschte Operation") zu Folge haben, was auch nicht erkannt werden kann von einem AN-Code, weil viele Operatoren den AN-Code
beibehalten . Ein ANB-Code kann zusätzlich Fehler von ausgetauschten
Operatoren und ausgetauschten Operanden detektieren. Das
Codieren einer Variable x in ANB-Code ist definiert als xc =A * xf + Bx, wobei die statische Signatur Bx für jede
Eingangsvariable mit 0 < Bx < A gewählt werden kann.
Tritt ein Bit Flip auf dem Adress-Bus auf, wenn die Variable y, gespeichert wird, kann eine verlorene Aktualisierung von yc auftreten, weil yc an eine falsche Speicher-Stelle gespeichert wird. Wenn yc das nächste Mal gelesen wird, kann die alte
Version von yc gelesen werden, welche korrekt AN- oder ANB- codiert aber veraltet sein kann.
Zum Ermitteln der Verwendung von veralteten Operanden, d.h. verlorener Aktualisierung, kann eine als solches bekannte
Version D verwendet werden, die die Variablen-Aktualisierungen zählt. Im resultierenden AND-Code kann die codierte Version von x wie folgt sein: xc = A * xf+ D. Im resultierenden ANBD- Code kann eine Variable x als xc = A * xf + Bx + D codiert werden. Der Code-Überprüfer muss das erwartete D wissen zum Überprüfen der Validität von Code-Wörtern. Gemäß
Ausführungsformen kann eine AND- oder ANBD-Code- Implementierung verwendet werden, die Versionen nur auf den Speicher, auf den während Lade- und Speicher-Instruktionen zugegriffen wird, aber nicht auf Register anwendet. Dieser Code kann daher als ANDmem- bzw. ANBDmem-Code bezeichnet werden .
Zur Veranschaulichung sei folgender uncodierter C-Code der Funktion f betrachtet: i n t f ( i n t x , i n t y . i t z ) {
i t u = x + y ;
Int v = u z ;
ro t ii in v ;
Die codierte Version dieser Funktion f kann nur codierte verwenden, z.B. AN-, ANB-, AND- oder ANBD-codierte Daten i ix t c. f ( i n t _c xc , i n t c yc , i n t. c zc ) {
int_c ic — xc + yc ; // uc — A* xf+Bx + A * yf+By
// = A(xf+yf)+Bx+By
mt_c vc = uc + zc // vc = A ( xf+yf+ zf)+Bx+By+Bz
return vc
Der oben angegebene Pseudo-Code ist der Übersichtlichkeit halber vereinfacht und ignoriert Über- und Unterlauf- Problematiken. Die angegebenen Kommentare im Quellcode geben den Variablen-Inhalt im fehlerfreien Fall bei Verwendung eines ANB-Codes an.
Bei einem AN-Code können die Verlangsamungen im Bereich von einem Faktor 2 (z.B. für das Sieb des Eratosthenes ) bis zu einem Faktor 75 (z.B. für eine Implementierung eines Verkehrs- Warn- und Kollisions-Vermeidungs-System für Flugzeuge) liegen, je nachdem, ob die Anwendungen teure codierte Operationen wie Multiplikationen oder Fließkomma-Operationen verwenden.
Der ANB-Code kann im Durchschnitt 1,9 mal langsamer sein als der AN-Code, weil er codierten Kontroll- und Daten-Fluss bereitstellt und die verwendeten codierten Operationen
ebenfalls die Signaturen berücksichtigen müssen.
Es ist daher wünschenswert, eine Codierung zu finden, die ähnlich sicher wie der AN-Code oder der ANB-Code ist und gleichzeitig schneller in Hinblick auf die Laufzeit ist. Eine Ursache für die Verlangsamungen eines AN- oder ANB-codierten Programms sind teure Divisionen, die beim Decodieren verwendet werden müssen.
Gemäß Ausführungsformen können die Daten mindestens zweimal mittels der AN-, ANB-, AND-, ANBD-Codierung codiert werden und jede Operation kann auf jeweils jeder codierten Kopie der Daten ausgeführt werden.
Gemäß Ausführungsformen können die Daten mindestens zweimal mittels der AN-Codierung codiert werden, z.B. kann die
Variable x zu xci = Ai * xf und xC2 = A2 * Xf codiert werden. Jede Operation kann auf jeweils jeder codierten Kopie der Daten ausgeführt werden. Beispielsweise kann die Funktion f als f (xci, yci, zci) und als f (xC2, yC2, zC2) ausgeführt werden, wobei die Variablen xclr ycl und zci jeweils mit dem ersten Multiplikator Ai codiert sind und die Variablen xC2, yC2 und zC2 jeweils mit dem zweiten Multiplikator A2 codiert sind. Für die Multiplikatoren Ai und A2, bzw. für die Multiplikatoren Ai bis An im Fall von n-fachen Codieren und Ausführen mit n gleich oder größer als die Zahl 2, können beliebige Zahlenwerte gewählt werden, solange sich das Multiplikatoren-Paar oder die Multiplikatoren-Paare um genau eine Potenz mit Basis 2
unterscheidet oder unterscheiden. Diese Art der Kodierung wird im Folgenden delta-Kodierung genannt. Gemäß Ausführungsformen kann sich jedes Multiplikatoren-Paar, das aus den zwei oder mehreren verschiedenen Multiplikatoren gebildet werden kann, um eine Potenz mit Basis 2
unterscheiden .
Gemäß Ausführungsformen können sich lediglich diejenigen
Multiplikatoren-Paare, denen Ergebniswerte einer ausgeführten Operation zugeordnet sind, die miteinander verglichen werden, z.B. decodiert, verifiziert oder überprüft werden, um eine Potenz mit Basis 2 unterscheiden.
Gemäß Ausführungsformen kann jeder Multiplikator größer als die Zahl 1 sein. Gemäß Ausführungsformen kann jeder
Multiplikator eine ganze Zahl sein. Gemäß Ausführungsformen kann jeder Multiplikator ein oder mehrere Nachkommastellen aufweisen .
Gemäß Ausführungsformen können die Daten drei- oder viermal mittels der AN-Codierung codiert werden und jede Operation kann auf jeweils allen codierten Kopien der Daten ausgeführt werden.
Gemäß vorteilhaften Ausführungsformen können die Daten zweimal oder sogar öfter mittels der AN-Codierung codiert werden und jede Operation kann auf jeweils beiden codierten Kopien der Daten ausgeführt werden.
Gemäß Ausführungsformen können jeweils zwei codierte Kopien eines Zahlenwerts aus den mindestens zwei codierten Kopien des Zahlenwerts zu einem decodierten Zahlenwert decodiert werden mittels eines Verschiebens der Ziffern des Ergebnisses der Differenz der codierten ersten und der zweiten codierten Kopie in Richtung der Ziffernposition mit dem niedrigsten Wert.
Zur Veranschaulichung sei folgendes Beispiel betrachtet: xci = Ai * xf
xc2 = A2 * Xf
mit
Ai = A2 - 21.
Zum Decodieren kann xd = ( Ai - A2 ) >> i ermittelt werden. Im Fall von Ai = A2 - 1 kann xd als die Differenz Ai - A2 der
Multiplikatoren Ai und A2 ermittelt werden.
Gemäß Ausführungsformen können die mindestens zwei codierten Kopien eines Zahlenwerts (oder anschaulich einer Variablen) auf eine gültige Codierung hin überprüft werden, indem jeweils zwei Kopien des Zahlenwerts aus den mindestens zwei codierten Kopien des Zahlenwerts wie oben beschrieben decodiert werden. Danach kann der Ergebniswert des Decodierens dieser beiden Kopien erneut mittels des zugeordneten ersten und/oder zweiten Multiplikators codiert werden. Der mit dem ersten
Multiplikator erneut codierte Wert kann mit der ersten Kopie verglichen werden und der mit dem zweiten Multiplikator erneut codierte Wert kann mit der zweiten Kopie verglichen werden.
Im Fall des obigen Beispiels wird die Variable x zunächst zu xd decodiert. Danach wird mindestens ein decodierter Wert xd erneut codiert: x' d = Ai * xd X C2 = A2 * Xd.
Es können die Ergebniswerte ferner mittels der Modulus- Operation überprüft werden.
Gemäß verschiedenen Ausführungsformen kann nach einem
redundanten Ausführen einer Anweisung oder erst nach einem redundanten Ausführen mehrerer Anweisungen ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist. Dabei können mindestens zwei spezielle Register, z.B. Akkumulatoren, verwendet werden, die nach jedem redundanten Ausführen einer Anweisung mit dem Ergebnis der Anweisung inkrementiert werden. Beispielsweise wird ein erstes Register (oder ein erster Akkumulator) mit dem ersten Ergebnis des ersten Ausführens einer Anweisung inkrementiert und ein zweites Register (oder ein zweiter Akkumulator) wird mit dem zweiten Ergebnis des zweiten Ausführens einer Anweisung inkrementiert . Beispielsweise kann für den folgenden Code-Abschnitt z = x + y;
z = z - 3 ; der codierte Code-Abschnitt
Zi = Xi + yi ; z2 = x2 + y2;
accui = accui + ζΐΓ· accu2 = accu2 + z2;
zi = zi - 3 *Ai; z2 = z2 - 3 *A2;
accui = accui + ζΐΓ· accu2 = accu2 + z2; erzeugt und ausgeführt werden.
Für die speziellen Register accui und accu2 kann jeweils mittels z.B. der Modulus-Operation überprüft werden, ob sie ein gültiges Codewort aufweisen. Ferner können die speziellen Register accui und accu2 gemeinsam auf eine gültige Codierung hin überprüft werden, indem sie jeweils wie oben beschrieben decodiert werden, das jeweilige Ergebnis des Decodierens erneut mittels des zugeordneten ersten und/oder zweiten
Multiplikators codiert wird und die erneut codierten Werte jeweils mit dem entsprechenden Register accui,2 verglichen werden.
Indem nicht nach jedem redundanten Ausführen einer Anweisung ermittelt wird, ob ein Fehler aufgetreten ist, kann die
Ausführung des codierten Programms beschleunigt werden.
Gemäß verschiedenen Ausführungsformen können die
Multiplikatoren als ein Vielfaches der Zahl 2 gewählt werden, um eine effiziente Implementierung der Modulus-Operation nutzen zu können.
Gemäß verschiedenen Ausführungsformen können die
Multiplikatoren nicht als ein Vielfaches der Zahl 2 gewählt werden, um eine bessere Sicherheit gegenüber Fehlern zu gewährleisten, z.B. gegenüber Bit-Flips.
Gemäß verschiedenen Ausführungsformen können fehlerhafte codierte Zahlenwerte, also Zahlenwerte die beim Überprüfen keinem gültigen Codewort entsprechen, mittels mindestens eines anderen codierten Wertes korrigiert werden, wobei der
fehlerhafte codierte Zahlenwert und der mindestens eine andere codierte Wert dem gesuchten Zahlenwert entsprechen. Gemäß Ausführungsformen kann der mindestens eine andere codierte Wert, der zum Korrigieren verwendet werden kann, einem
Überprüfen standhalten.
Gemäß verschiedenen Ausführungsformen können sowohl Operanden einer Funktion oder Operation als auch Ergebnisse korrigiert werden, sofern diese codiert sind. Gemäß verschiedenen Ausführungsformen kann wegen der Redundanz eine höhere Erkennungsrate von Fehlern erzielt werden als bei einem herkömmlichen AN-Codieren. Gemäß verschiedenen Ausführungsformen können wegen der
Redundanz Fehler korrigiert werden.
Gemäß verschiedenen Ausführungsformen kann wegen des
Vermeidens teurer Rechenoperationen trotz redundanter
Ausführung, z.B. zweifacher Ausführung, gegenüber der
herkömmlichen AN-Codierung Rechenzeit gespart werden. Gemäß verschiedenen Ausführungsformen kann gerade wegen der
redundanten Ausführung Rechenzeit gespart werden, weil die Parameter der Codierung so gewählt werden können, dass die zum Codieren, Decodieren und/oder Überprüfen benötigten
Rechenoperationen effizient implementiert werden können.
Gemäß Ausführungsformen können wegen der Redundanz geringere Anforderungen bezüglich der Multiplikatoren gestellt werden als bei einer einfach durchgeführten arithmetischen Codierung, z.B. Potenzen mit Basis 2 gewählt werden, Zahlen gewählt werden, die keine Primzahlen sind, oder Zahlen mit weniger Stellen als bei dem einfachen AN-Codieren gewählt werden.
Gemäß Ausführungsformen können wegen der Redundanz einfachere, effizienter zu verarbeitende und/oder weniger sichere
Multiplikatoren als bei dem einfach durchgeführten AN-Codieren gewählt werden. Dadurch kann weitere Rechenzeit gespart werden.
Fig.8 zeigt eine Darstellung 800 gemäß einer Ausführungsform, welche das delta-Codieren und Ausführen eines Programms 802 sowie das Decodieren und Überprüfen des codierten Ergebnisses illustriert.
Das nicht codierte Originalprogramm 802 kann mittels des
Parameterpaares 804 zu einem codierten Programm 806 codiert werden, dargestellt mittels des Pfeils 808. Das Parameterpaar 804 kann die Bedingung 810 erfüllen, z.B. dass der erste
Multiplikator Ai gleich dem zweiten Multiplikator A2 plus der Zahl 1 ist. Das Parameterpaar 804 kann aber auch eine andere Bedingung (nicht dargestellt) erfüllen, z.B. dass der erste Multiplikator Ai gleich dem zweiten Multiplikator A2 plus eine Potenz mit Basis 2 ist.
Jeder Multiplikator des Parameterpaares 804 kann einem
arithmetischen Code zugeordnet sein, z.B. demselben
arithmetischen Code, z.B. einem AN-Code. Der erste
Multiplikator kann auch einem anderen arithmetischen Code zugeordnet sein als der zweite Multiplikator, z.B. können die beiden Multiplikatoren jeweils einem AN-Code und einem AND- Code zugeordnet sein.
Das Programm 802 kann die Variablen x und y aufweisen. Als Ergebnis z kann x plus y berechnet werden. Der verständlichen Erklärung halber können die Variablen x und y Konstanten sein.
Bei dem Codieren 808 kann zum Erzeugen des codierten Programms 806 die Konstante x dupliziert werden und es können die codierten Kopien xi und X2 der Konstanten ermittelt werden. Auch die Konstante y kann dupliziert werden und es können die codierten Kopien yi und 2 der Konstanten ermittelt werden. Die ersten Kopien xi, yi der Konstanten x und y werden addiert und die zweiten Kopien X2, y2 der Konstanten x und y werden
addiert. Als Optimierung (nicht dargestellt) können die codierten Kopien der Konstanten bereits vor dem Ausführen addiert werden, sofern die Parameter für die arithmetischen Codierungen zum Zeitpunkt der Optimierung bekannt sind.
Das codierte Programm 806 kann codiert ausgeführt werden, dargestellt mittels des Pfeils 812. In dem ausgeführten
Programm 814 können die erste und die zweite Kopie zi und Z2 des Ergebnisses z ermittelt werden. Die codierten Variablen und die daraus resultierenden codierten Terme können bereits vor dem Ausführen, also vor der codierten Verarbeitung, in Abhängigkeit von den Variablen und Parametern optimiert werden, z.B. zu Termen umgeformt werden, deren Auswertung während des Ausführens des codierten Programms effizienter ist. Wenn die Parameter des arithmetischen Codes bereits vor der codierten Verarbeitung bekannt sind, können die in diesem Fall konstanten Werte z i , 2 vorab ermittelt werden, z.B. als Ai , 2 multipliziert mit der Konstanten 3. Im Fall einer redundant durchgeführten AN-Codierung können die Multiplikatoren Ai , A2 zum Zeitpunkt des Codierens 808 ermittelt werden und somit zum Zeitpunkt des codierten Ausführens 812 bekannt sein. Im Fall einer z.B. redundant durchgeführten ANB-Codierung können die Signaturen (nicht dargestellt) bei einer dynamischen
Speicherverwaltung erst zum Zeitpunkt des codierten Ausführens 812 zugeordnet werden.
Das ausgeführte codierte Programm 814 kann decodiert werden, dargestellt mittels des Pfeils 816. Nach dem Decodieren 816 kann ein decodiertes Ergebnis 818, 820, 822 erhalten werden. Das decodierte Ergebnis 818, 820, 822 kann überprüft werden, dargestellt mittels der Pfeile 824, 826, 828. Beispielsweise kann überprüft werden 824, 826, 828, ob ein erneut codierter Ergebniswert gleich dem entsprechenden codierten Ergebniswert ist. Das erneute Codieren und Vergleichen kann für das
Parameterpaar 804 durchgeführt werden oder für ein oder mehrere Parameterpaare (nicht dargestellt) in dem Fall, dass das Programm 802 mit mehr als zwei Parametersätzen, z.B. mehr als zwei Multiplikatoren, codiert und ausgeführt wurde.
Beim Überprüfen 824, 826, 828 kann ein Überprüfungs-Ergebnis 830, 832, 834 ermittelt werden. Wenn die erneut codierten redundanten Ergebniswerte z ' i , z ' 2 gleich den codierten
redundanten Ergebniswerten z i , z2 sind, kann das codierte
Verarbeiten 808 erfolgreich sein. Wenn mindestens ein erneut codierter Ergebniswert z ' i , 2 ungleich dem entsprechenden codierten Ergebniswert z i , 2 ist, kann das codierte
Verarbeiten 808 fehlgeschlagen, fehlerhaft oder fehlerbehaftet sein. In diesem Fall kann versucht werden, einen korrekt codierten Ergebniswert zu detektieren, dargestellt mittels der Pfeile 836 und 838. Beim Detektieren 836, 838 eines korrekt codierten Ergebniswerts kann ein Korrektur-Ergebnis 840, 842 ermittelt werden. Für die Parameter 804 können der Wert 6 für den ersten
Multiplikator Ai und der Wert 5 für den zweiten Multiplikator A2 gewählt sein. Bei einem codierten Ausführen 812 kann beispielsweise mittels dieser Parameter Ai, A2 für das erste codierte Ergebnis zi der Wert 18 und für das zweite codierte Ergebnis Z2 der Wert 15 ermittelt werden. Als decodiertes Ergebnis 818 kann der Wert 3 ermittelt werden. Beim Überprüfen 824 kann das decodierte Ergebnis erneut mittels der Parameter codiert werden, wobei ebenfalls die Werte 15 und 18 ermittelt werden können. Daher kann als Überprüfungs-Ergebnis 830 ermittelt werden, dass das decodierte Ergebnis 818 korrekt ist .
Bei dem codierten Ausführen 812 können aber auch im Fall eines Fehlers andere, falsche Ergebniswerte ermittelt werden.
Beispielsweise kann für den ersten codierten Ergebniswert der richtige Wert 18 und für den zweiten codierten Ergebniswert der falsche Wert 11 ermittelt werden. Das decodierte Ergebnis 820 kann sich aus der Differenz dieser beiden codierten
Ergebniswerte ergeben, weil die Differenz zwischen dem ersten und dem zweiten Multiplikator gemäß der Bedingung 810 den Wert 1 betragen kann, welcher der Zahl 2 hoch der Zahl 0
entspricht. Als decodiertes Ergebnis 820 kann der falsche Wert 7 ermittelt werden. Beim Überprüfen 826 kann ermittelt werden, dass weder der erneut codierte erste Ergebniswert, z.B. der
Wert 42, noch der erneut codierte zweite Ergebniswert, der der Wert 35, mit dem beim codierten Verarbeiten 812 ermittelten ersten bzw. zweiten codierten Ergebniswert übereinstimmen. Daher kann als Überprüfungsergebnis 832 ein Fehler detektiert werden. Ferner kann überprüft werden, ob der beim codierten Verarbeiten 812 ermittelte erste bzw. zweite codierte
Ergebniswert die Bedingung oder die Bedingungen des beim
Codieren 808 verwendeten arithmetischen Codes erfüllen, also ob sie einem gültigen Codewort entsprechen. Im Fall eines AN- Codes kann dies mittels der Modulus-Operation, anders
ausgedrückt mittels des Restwerts bei Teilung durch den beim Codieren 808 verwendeten Multiplikator, detektiert werden. Es kann als Korrektur-Ergebnis 840 ermittelt werden, dass der erste codierte Ergebniswert z i korrekt ist, also ein gültiges Codewort ist, und dass der zweite codierte Ergebniswert Z2 falsch oder fehlerhaft ist, also kein gültiges Codewort ist. Der korrekt codierte Ergebniswert, in diesem Beispiel der erste codierte Ergebniswert, kann zum Korrigieren (nicht dargestellt) des Fehlers verwendet werden. Gemäß
Ausführungsformen kann nur ein korrekter codierter
Ergebniswert decodiert werden zum Ermitteln des decodierten Ergebnisses. Bei einem mehr als zweimaligen Codieren und/oder Ausführen, kann ferner ermittelt werden, welcher decodierte
Ergebniswert am häufigsten ermittelt wurde und dieser kann als decodiertes Ergebnis gewählt werden.
Als ein anderes Beispiel kann für den ersten codierten
Ergebniswert der falsche Wert 24 und für den zweiten codierten Ergebniswert der falsche Wert 15 ermittelt werden. Als
decodiertes Ergebnis 822 kann der falsche Wert 9 ermittelt werden. Bei einem ersten Überprüfen 828 kann ermittelt werden, dass keiner der erneut codierten Ergebniswerte mit den
entsprechenden beim codierten Verarbeiten 812 ermittelten codierten Ergebniswerten übereinstimmt. Daher kann als
Überprüfungs-Ergebnis 834 ein Fehler detektiert werden. Bei einem zweiten Überprüfen 838, ob die beim codierten
Verarbeiten 812 ermittelten codierten Ergebniswerte jeweils die Bedingungen des beim Codieren 808 verwendeten
arithmetischen Codes erfüllen, kann ermittelt werden, dass die codierten Ergebniswerte alle gültige Codeworte sind, obwohl sie, wie bereits beim ersten Überprüfen festgestellt,
fehlerhaft sind. Daher kann als Korrektur-Ergebnis 842
festgestellt werden, dass keiner der codierten Ergebniswerte zum Fehlerkorrigieren verwendet werden kann.
Gemäß Ausführungsformen können der erste und der zweite
Multiplikator derart gewählt werden, z.B. hinreichend groß gewählt werden, dass bei Auftreten eines Fehlers, z.B. eines Bit-Flips, mit einer hohen Wahrscheinlichkeit kein gültiges Code-Wort resultiert. Selbst wenn sich aufgrund von Fehlern zwei gültige Code-Worte ergeben sollten, kann ein Fehler detektiert werden, weil keiner der erneut codierten Ergebniswerte mit den entsprechenden beim codierten
Verarbeiten 812 ermittelten codierten Ergebniswerten
übereinstimmt .
Gemäß Ausführungsformen kann das Programm 802 mehrfach (nicht dargestellt) mit verschiedenen Parameterpaaren 804 codiert werden 808, jedes codierte Programm 806 kann codiert
verarbeitet werden 812 und jedes codierte Ergebnis des
ausgeführten codierten Programms 814 kann decodiert 816 und überprüft werden 824, 826, 828 und/oder es kann versucht werden das decodierte Ergebnis 818, 820, 822 zu korrigieren 836, 838. Gemäß Ausführungsformen kann das codierte Programm 806 im Fall eines Fehlers erneut codiert 812 verarbeitet werden,
beispielsweise ohne es erneut zu codieren.
Gemäß Ausführungsformen kann das codierte Programm 806 im Fall eines Fehlers erneut codiert 812 verarbeitet werden, wobei häufiger, also öfters, auf potentielle Fehler geprüft werden kann .
Gemäß Ausführungsformen kann der decodierte Ergebniswert als korrigiertes decodiertes Ergebnis ermittelt werden, der am häufigsten ermittelt wurde.
Gemäß Ausführungsformen kann ein Fehler detektiert werden, wenn mindestens einer der erneut codierten Ergebniswerte nicht mit dem entsprechenden beim codierten Verarbeiten 812
ermittelten codierten Ergebniswerten übereinstimmt.
Gemäß Ausführungsformen kann überprüft werden, ob ein oder mehrere codierte Ergebniswerte gültige Codewort sind, nachdem ein Fehler detektiert worden ist. Fig.9 zeigt eine Darstellung 900 gemäß einer Ausführungsform, welche einen Speicher 902 mit zwei Puffern 904, 906
illustriert . Jeder Puffer 904, 906 kann eine Basisadresse 908, 910, z.B. die Startadresse, aufweisen. An einer Adresse 912, 914, 916 kann ein Wert 918, 920, 922 gespeichert werden, z.B. ein codierter Zahlenwert. Der codierte Zahlenwert kann mit einer Signatur, die auf seine Speicheradresse 912, 914, 916 basiert sein kann, mittels einer ausschließlichen oder (XOR) -Operation verknüpft werden. Wenn der Wert 918, 920, 922 aus dem Speicher geladen wird, kann er erneut mit dieser Signatur mittels einer ausschließlichen oder (XOR) -Operation verknüpft werden, um wieder den codierten Zahlenwert zu erhalten.
Die Speicheradresse 912, 914, 916, an der der Wert 918, 920, 922 gespeichert oder von der der Wert 918, 920, 922 geladen werden soll, kann codiert werden, z.B. mittels eine AN-Codes codiert werden. Eine erste Kopie der Speicheradresse 912, 914, 916 kann mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert werden und eine zweite Kopie der Speicheradresse 912, 914, 916 kann mittels eines
arithmetischen Codes aufweisend einen zweiten Multiplikator codiert werden.
Auch jede Variable, die in dem Speicher 902 gespeichert werden soll, z.B. einem ungeschützten Speicher, kann mittels jeweils eines ersten und eines zweiten Multiplikators codiert werden. Eine erste codierte Kopie der Variablen kann als erster codierter Wert 918 an einer ersten Speicheradresse 912
gespeichert werden. Eine zweite codierte Kopie der Variablen kann als zweiter codierter Wert 920 an einer zweiten
Speicheradresse 914 gespeichert werden. Zum Beispiel können der erste codierte Wert 918 und der zweite codierte Wert 920 innerhalb des ersten Puffers 904 gespeichert werden.
Die ersten und zweiten Multiplikatoren zum Codieren von
Variablenwerten können sich von den ersten und zweiten Multiplikatoren zum Codieren von Speicheradressen 910, 912, 914 unterscheiden. Es können aber auch jeweils dieselben ersten bzw. zweiten Multiplikatoren zum Codieren der Variablen und zum Codieren der Speicheradresse 912, 914, 916 verwendet werden.
Gemäß Ausführungsformen können zwei oder mehr codierte Kopien einer Variablen gespeichert werden, z.B. zwei oder mehr AN- codierte Kopien, die jeweils mit einer Speicheradressen- Signatur mittels einer ausschließlichen oder (XOR) -Operation verknüpft sind.
Gemäß Ausführungsformen können zwei oder mehr Kopien einer Speicheradresse 912, 914, 916 codiert werden. In anderen
Worten können einer Speicheradresse 912, 914, 916 zwei oder mehr Speicheradressen-Signaturen zugeordnet werden, z.B. AN- codierte Speicheradressen.
Eine Speicheradresse 912, 914, 916 kann mittels eines
arithmetischen Codes aufweisend einen ersten Multiplikator codiert werden, z.B. zu einer ersten codierten
Speicheradresse pAi . Die Speicheradresse 912, 914, 916 kann ferner mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert werden, z.B. zu einer zweiten codierten Speicheradresse pA2 · Bei einem Zugriff auf eine
Speicheradresse kann die Speicheradresse mittels der ersten und der zweiten codierten Speicheradresse decodiert werden, beispielsweise mittels der Differenz der ersten und der zweiten codierten Speicheradresse, beispielsweise mittels der Differenz gefolgt von einem Verschieben, beispielsweise mittels der Differenz gefolgt von einem Bit-Verschieben .
Die erste codierte Kopie einer Variablen, z.B. eine AN- codierte Kopie, kann an der ersten Speicheradresse 912 gespeichert werden, indem sie mit der ersten codierten
Speicheradresse px Ai der ersten Speicheradresse und/oder mit der zweiten codierten Speicheradresse px A2 der ersten Speicheradresse verknüpft wird, z.B. mittels der
ausschließlichen oder (XOR) -Operation .
Die zweite codierte Kopie einer Variablen, z.B. eine AN- codierte Kopie, kann an der zweiten Speicheradresse 914 gespeichert werden, indem sie mit der ersten codierten
Speicheradresse p2 Ai der zweiten Speicheradresse und/oder mit der zweiten codierten Speicheradresse p2 A2 der zweiten
Speicheradresse verknüpft wird, z.B. mittels der
ausschließlichen oder (XOR) -Operation .
Die erste codierte Kopie einer Variablen, z.B. eine AN- codierte Kopie, kann von der ersten Speicheradresse 912 geladen werden, indem sie mit der ersten codierten
Speicheradresse px Ai der ersten Speicheradresse und/oder mit der zweiten codierten Speicheradresse px A2 der ersten
Speicheradresse verknüpft wird, z.B. mittels der
ausschließlichen oder (XOR) -Operation . Die zweite codierte Kopie einer Variablen, z.B. eine AN- codierte Kopie, kann von der zweiten Speicheradresse 914 geladen werden, indem sie mit der ersten codierten
Speicheradresse p2 Ai der zweiten Speicheradresse und/oder mit der zweiten codierten Speicheradresse p2 A2 der zweiten
Speicheradresse verknüpft wird, z.B. mittels der
ausschließlichen oder (XOR) -Operation .
Gemäß verschiedenen Ausführungsformen kann eine
Speicheradressen-Signatur, mit welcher ein Wert 918, 920, 922 verknüpft wird, die erste codierte Speicheradresse pAi, die zweite codierte Speicheradresse pA2 oder beide codierten
Speicheradressen aufweisen, beispielsweise können beide codierten Speicheradressen mittels einer ausschließlichen oder (XOR) -Operation miteinander verknüpft werden. Gemäß
Ausführungsformen kann eine Speicheradressen-Signatur eine oder mehrere der ihr entsprechenden codierten Speicheradressen aufweisen . Gemäß verschiedenen Ausführungsformen kann detektiert werden, ob eine falsche Variable aus dem Speicher geladen wird, weil das Verknüpfen mit einer Speicheradressen-Signatur, welche nicht der geladenen Variablen zugeordnet ist, mittels der ausschließlichen oder (XOR) -Operation mit hoher
Wahrscheinlichkeit in ein ungültiges Code-Wort resultiert. Eine Variable kann zum Beispiel an einer falschen
Speicheradresse gespeichert werden oder von einer falschen Speicheradresse geladen werden, wenn im Adress-Bus ein transienter Fehler auftritt.
Gemäß Ausführungsformen können Fehler von ausgetauschten Operanden detektiert werden. Gemäß Ausführungsformen können ähnliche Garantien wie beim ANB-Codieren bereitgestellt werden, wenn ein AN-codierter Wert 918, 920, 922 mit seiner Speicheradressen-Signatur mittels der ausschließlichen oder (XOR) -Operation verknüpft wird.
Gemäß verschiedenen Ausführungsformen kann so die
Verlangsamung beim Ausführen des codierten Programmes
verringert werden. Beispielsweise können ein delta-codiertes Programm oder ein delta-codiertes Programm inklusive
Speicheradressen-Signaturen schneller ausgeführt werden als ein ANB-codiertes Programm.
Gemäß verschiedenen Ausführungsformen kann eine
Speicheradressen-Signatur, mit welcher ein Wert 918, 920, 922 verknüpft wird, eine Basisadressen-Signatur aufweisen, wobei die Basisadresse 908, 910 dem Puffer 904, 906 zugeordnet ist, in dem der Wert 918, 920, 922 gespeichert werden soll.
Eine codierte Kopie einer Variablen, z.B. eine AN-codierte Kopie, kann an der Speicheradresse 912, 914, 916 gespeichert werden, indem sie vor dem Speichern in dem Speicher 902 mit einer Basisadressen-Signatur verknüpft wird, wobei jeder
Puffer 904, 905 eine eigene Basisadressen-Signatur aufweist. Anders ausgedrückt kann jedem Puffer 904, 906 eine
Speicheradresse, die sogenannte Basisadresse, eindeutig zugeordnet werden, anhand welcher die Basisadressen-Signatur ermittelt wird. Zum Beispiel kann die codierte Kopie jeweils mit einer oder mehreren codierten Basisadressen, und
zusätzlich mit jeweils einer oder mehreren codierten
Speicheradressen verknüpft werden.
Eine codierte Kopie einer Variablen, z.B. eine AN-codierte Kopie, kann von der Speicheradresse 912, 914, 916 geladen werden, indem sie nach dem Laden aus dem Speicher 902 mit einer Basisadressen-Signatur verknüpft wird, z.B. mit einer oder mehreren codierten Basisadressen, und zusätzlich mit einer oder mehreren codierten Speicheradressen verknüpft wird.
Wenn beispielsweise ein gespeicherter Wert 918, 920 in dem ersten Puffer 904 durch einen Wert 922 des zweiten Puffers überschrieben wird, egal ob ausversehen oder absichtlich durch einen Überlauf des zweiten Puffers 906 verursacht, kann dies mittels der Basisadressen-Signatur leicht detektiert werden. Denn der Wert 922 des zweiten Puffers 906 wäre nicht mit der ersten Basisadressen-Signatur verknüpft, sondern z.B. mit der zweiten Basisadressen-Signatur im Fall eines Pufferüberlaufs oder mit z.B. irgendeiner geratenen oder willkürlichen
Signatur im Fall eines Angriffs. Die Reihenfolge der Verknüpfungen und/oder die Reihenfolge des Auswertens der Verknüpfungen können beliebig sein. Wichtig ist, dass die codierte Kopie einer Variablen (in anderen
Worten der Wert 918, 920, 922) beim Speichern und beim Laden mit denselben Signaturen verknüpft wird.
Gemäß Ausführungsformen werden zu speichernde und mittels eines arithmetischen Codes codierte Zahlenwerte mittels einer selbstinversen Operation verknüpft. Gemäß Ausführungsformen werden zu ladende und mittels des arithmetischen Codes
codierte Zahlenwerte mittels derselben Operation und demselben Operanden, also derselben Speicheradressen-Signatur, wie beim Speichern verknüpft zum Detektieren, ob beim Speichern oder Laden ein Fehler aufgetreten ist. Gemäß Ausführungsformen können verschiedene Teilbereiche oder Abschnitte eines Systems, z.B. eines Computersystems, z.B. verschiedene Programme oder Anwendungen, mit verschiedenen Multiplikatoren codiert werden. Falls ein Teilbereich des
Systems die Daten eines anderen Teilbereichs überschreibt bzw. verändert kann dies detektiert werden, weil die Daten mit verschiedenen, dem anderen Teilbereich nicht bekannten
Multiplikatoren codiert sind.
Gemäß Ausführungsformen kann das Codieren einer Anwendung oder eines Programms, d.h. das ihr oder ihm Ermöglichen, codierte Daten zu verarbeiten, zu verschiedenen Abschnitten der
Lebensdauer der Anwendung oder des Programms erfolgen: vor dem Compilieren durch Codieren des Quell-Codes, während des
Compilierens durch Codieren einer Zwischen-Repräsentation des Programms, oder zur Laufzeit durch Codieren des Binär- Programms (englisch: Binary) während der Ausführung. Zum Codieren eines Programms mit einem arithmetischen Code, z.B. einem AN-Code, kann es erwünscht sein, dass jede
Instruktion und jede Variable durch ihre passend codierte Version ersetzt wird und dass jede Instruktion und jede
Variable mindestens verdoppelt werden, codiert jeweils mit zumindest einem unterschiedlichen Multiplikator. Gemäß
Ausführungsformen kann folgendes bereitgestellt werden, wie weiter unten näher beschrieben wird:
1. Jeweils mindestens zwei codierte Kopien aller
Instruktionen,
2. Mindestens zweifaches Codieren aller Konstanten und
Initialisierungs-Werte,
3. Verarbeitung von Aufrufen zu externen Bibliotheken, und
4. Encodieren von Daten-Fluss, beispielsweise durch
Überprüfen, dass Instruktionen mit den richtigen Operanden aufgerufen und korrekt codierte Ergebnisse berechnet werden.
Grundlegende arithmetische und boolesche Operationen können codiert werden, wie es als solches bekannt ist, z.B. mit dem AN-Code. Codieren komplexerer Operationen wie bitweise
logische Operationen, Typ-Umwandlung, Schiebe-Operationen, oder Fließkomma-Operationen können ebenfalls codiert werden, wie es als solches bekannt ist. Gemäß Ausführungsformen wird ein Codieren von Daten bereitgestellt.
FIG.10 zeigt eine Datenverarbeitungsanordnung 1000 gemäß einem Ausführungsbeispiel. Quellcode 1002 kann einem Compiler 1004 (beispielsweise einem Software-Codier-Compiler) zugeführt werden. Der Compiler 1004 kann dann eine sichere
Programmvariante 1006 erzeugen. Durch Übersetzen,
beispielsweise einschließlich Linken, wird die Sichere
Programmvariante 1006 in ein ausführbares codiertes Programm 1008 überführt, das beispielsweise auf Standard-Hardware und einem Standard-Betriebssystem 1012 ausgeführt werden kann. Es kann eine codierte Ausführung 1010 des ausführbaren codierten Programms 1008 stattfinden. Ausgabewerte 1014 des ausführbaren codierten Programms 1008 können durch einen sicheren Watchdog (anders ausgedrückt einem sicheren Überprüfungs-Schaltkreis 1018) verifiziert werden, dargestellt durch Pfeil und Kreis 1022. Die Verifikation kann dadurch ausgeführt werden, dass die codierte Ausführung 1010 codierte Zahlenwerte an den sicheren Watchdog 1018 sendet, der diese Werte überprüft. Zum Beispiel können codierte Ergebniswerte oder codierte
Ausgabewerte 1016 sowie die zugehörigen Multiplikatoren an den Watchdog 1018 gesendet werden.
Im Fall, dass beim Überprüfen ermittelt wird, dass ein Fehler aufgetreten ist, kann der Watchdog die Ausführung des
gesicherten Programms abbrechen.
Ausgaben können auch direkt durch den Watchdog laufen. Dazu können die beiden codierten ein oder mehreren Ausgabewerte mit den beiden Multiplikatoren an den Überprüfungs-Schaltkreis gesendet werden. Der Überprüfungs-Schaltkreis prüft nun die codierten Ausgaben. Wenn diese die Prüfung bestanden haben, decodiert der Überprüfungs-Schaltkreis die Ausgaben und gibt diese decodierten Ausgaben aus. Gemäß Ausführungsformen kann ein Überprüfungs-Schaltkreis (Watchdog) verwendet werden zum Überprüfen der korrekten
Ausführung des codierten Programms während seiner Laufzeit. Der Überprüfungs-Schaltkreis kann außerhalb des codierten
Programms angeordnet sein, also beispielsweise kein Teil des codierten Programms sein. Gemäß Ausführungsformen kann der Überprüfungs-Schaltkreis zuverlässig außerhalb des codierten Programms ausgeführt werden.
Gemäß Ausführungsformen können sichere spezielle Anweisungen verwendet werden zum Überprüfen der korrekten Ausführung des codierten Programms während seiner Laufzeit. Die sicheren speziellen Anweisungen können von innerhalb des codierten Programms aufgerufen werden, also beispielsweise ein Teil des codierten Programms sein. Gemäß Ausführungsformen können die sicheren speziellen Anweisungen zuverlässig von innerhalb des codierten Programms ausgeführt werden. Anstelle von oder zusätzlich zu einer reinen Duplikation werden alle duplizierte Daten mittels arithmetischer Codes codiert und duplizierte Anweisungen auf den codierten Daten ausgeführt, um Fehler zu erkennen. Das Programm und die verarbeiteten Daten werden verändert. Bei einer Kombination von einem redundanten arithmetischen Codieren und redundanter Ausführung der codierten Instruktionen kann das Decodieren besonders effizient ohne teure Division durchgeführt werden. Aufgrund der redundanten Ausführung kann detektiert werden, wenn in einer Ausführung ein falscher Operator verwendet wird. Bei einer Verknüpfung von codierten Worten mit
Speicheradressen-Signaturen mittels einer selbstinversen
Funktion können überschriebene oder auf unzulässige Weise veränderte Speicherbereiche detektiert werden. Bei einer Kombination von dem redundanten arithmetischen
Codieren, dem Verknüpfen mit Speicheradressen-Signaturen und redundanter Ausführung der codierten Instruktionen können beliebige Fehler mit hoher Trefferquote sowohl in der Zentralen-Verarbeitungs-Einheit (central processing unit, CPU) als auch in dem Speicher, z.B. dem Arbeitsspeicher, z.B. dem Zufalls-Zugriffs-Speicher (random access memory, RAM)
detektiert werden. Eine Korruption der Daten kann effizient auf Software-Ebene verhindert werden.
Mittels einer Kombination von dem redundanten arithmetischen Codieren, dem Verknüpfen mit Speicheradressen-Signaturen und redundanter Ausführung der codierten Instruktionen können kleine Anwendungen geschützt werden, z.B. vollständig
geschützt werden, bei denen Datenintegrität von großer
Bedeutung ist, z.B. im Automobilbereich, bei Schaltkreisen zur Steuerung von Fabriken oder Fabrikationsabläufen und bei wölken (cloud) -basierten Diensten.
Hardware- und Software-Systeme, die mit dem redundanten arithmetischen Codieren, dem Verknüpfen mit Speicheradressen- Signaturen und redundanter Ausführung der codierten
Instruktionen ausgestattet sind, sind Fehler-tolerant
gegenüber beiden transienten und permanenten Hardware-Fehlern und bieten gleichzeitig Sicherheitsgarantien, wie z.B. Schutz gegenüber Puffer- oder Speicherüberläufen.

Claims

Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist,
das Verfahren aufweisend:
• Ausführen von codiertem Programm-Code;
• Ausführen mindestens einer Anweisung des codierten
Programm-Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines
arithmetischen Codes aufweisend einen ersten
Multiplikator codiert sind und ein oder mehreren
Operanden der mindestens einen Anweisung entsprechen;
• Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen; und
• Ermitteln, ob bei der Ausführung des Programms ein
Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren
Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.
Verfahren gemäß Anspruch 1, aufweisend
• Ermitteln einer ersten Speicheradressen-Signatur
basierend auf einer ersten Speicheradresse;
• Verknüpfen der ersten codierten ein oder mehreren
Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer ausschließlichen oder-Operation;
• Speichern der ersten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der ersten Speicheradresse ; • Ermitteln einer zweiten Speicheradressen-Signatur basierend auf einer zweiten Speicheradresse;
• Verknüpfen der zweiten codierten ein oder mehreren
Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels einer ausschließlichen oder-Operation; und
• Speichern der zweiten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der zweiten Speicheradresse .
Verfahren gemäß Anspruch 2, ferner aufweisend
• Laden der ersten codierten ein oder mehreren
Zahlenwerte aus dem Speicher an der ersten
Speicheradresse ;
• Verknüpfen der geladenen ersten ein oder mehreren
Zahlenwerte mit der ersten Speicheradressen-Signatur mittels der ausschließlichen oder-Operation;
• Laden der zweiten codierten ein oder mehreren
Zahlenwerte aus dem Speicher an der zweiten
Speicheradresse; und
• Verknüpfen der geladenen zweiten ein oder mehreren
Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder-Operation.
Verfahren gemäß Anspruch 3,
wobei das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, ferner aufweist:
Ermitteln, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein Fehler
aufgetreten ist, basierend auf den geladenen ersten und zweiten codierten ein oder mehreren Zahlenwerten, dem ersten Multiplikator und dem zweiten Multiplikator.
Verfahren gemäß einem der Ansprüche 2 bis 4,
wobei die erste Speicheradressen-Signatur auf einer ersten Basisspeicheradresse und/oder der ersten Speicheradresse basiert ist und wobei die zweite Speicheradressen-Signatur auf einer zweiten Basisspeicheradresse und/oder der zweiten Speicheradresse basiert ist. Verfahren gemäß einem der Ansprüche 1 bis 5, ferner aufweisend
• Decodieren eines ersten und zweiten codierten
Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes; und
• Auswählen des ersten Multiplikators und des zweiten Multiplikators derart, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist
Verfahren gemäß Anspruch 6,
• wobei das Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert ferner ein Verschieben der Ziffern des Ergebniswertes der Differenz des codierten ersten und zweiten
Zahlenwertes in Richtung der Ziffernposition mit dem niedrigsten Wert aufweist; und
• wobei der erste Multiplikator und der zweite
Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten
Zahlenwertes zu einem decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten
Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist.
Verfahren gemäß Anspruch 7,
wobei der erste Multiplikator gleich dem zweiten
Multiplikator subtrahiert um eine Basiszahl hoch einer Exponentenzahl ist.
Verfahren gemäß Anspruch 8,
wobei die Basiszahl gleich zwei ist und das Verschieben der Ziffern ein Bit-Verschieben der Ziffern um die
Exponentenzahl ist. Verfahren gemäß einem der Ansprüche 1 bis 9, ferner aufweisend
Korrigieren eines fehlerhaften decodierten Zahlenwertes mittels eines codierten ersten und zweiten Zahlenwertes, die jeweils dem decodierten Zahlenwert entsprechen.
Verfahren gemäß einem der Ansprüche 1 bis 10,
wobei der arithmetische Code ein arithmetischer Code mit
Signaturen ist.
Verfahren gemäß einem der Ansprüche 1 bis 11,
wobei der arithmetische Code aufweist mindestens einen
Code aus einer Gruppe von Codes bestehend aus:
• einem AN-Code;
• einem ANB-Code;
• einem AND-Code;
• einem ANDmem-Code;
• einem ANBD-Code; und
• einem ANBDmem-Code .
Verfahren gemäß einem der Ansprüche 1 bis 12,
wobei das Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, mittels eines Überprüfungs- Schaltkreises durchgeführt wird.
Verfahren gemäß Ansprüche 13, ferner aufweisend
Übermitteln der ersten codierten ein oder mehreren
Ergebniswerte, des ersten Multiplikators, der zweiten codierten ein oder mehreren Ergebniswerte und des zweiten Multiplikators von dem Programm an den Überprüfungs- Schaltkreis .
Verfahren gemäß einem der Ansprüche 1 bis 12,
wobei das Verfahren mittels eines Überprüfungs- Schaltkreises ausgeführt wird.
16. Verfahren gemäß einem der Ansprüche 13 bis 15, wobei der Überprüfungs-Schaltkreis außerhalb des Programms implementiert ist.
Verfahren gemäß einem der Ansprüche 13 bis 16,
wobei der Überprüfungs-Schaltkreis in sicherer Hardware implementiert ist.
Verfahren gemäß einem der Ansprüche 13 bis 17,
wobei der Überprüfungs-Schaltkreis durch Redundanz
abgesichert ist.
Verfahren gemäß einem der Ansprüche 12 bis 18,
wobei der Überprüfungs-Schaltkreis durch arithmetische
Codes abgesichert ist.
Verfahren zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler
aufgetreten ist,
das Verfahren aufweisend:
• Erzeugen eines Programm-Code-Abschnittes zum Codieren von ein oder mehreren Operanden mindestens einer
Anweisung des Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator;
• Erzeugen eines Programm-Code-Abschnittes zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte
Zahlenwerte mittels des arithmetischen Codes
aufweisend einen zweiten Multiplikator;
• Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den ersten
codierten ein oder mehreren Zahlenwerten;
• Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den zweiten
codierten ein oder mehreren Zahlenwerten; und
• Erzeugen eines Programm-Code-Abschnittes zum
Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten
Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator.
Verfahren gemäß Anspruch 20, aufweisend
• Erzeugen eines Programm-Code-Abschnittes zum Ermitteln einer ersten Speicheradressen-Signatur basierend auf einer ersten Speicheradresse;
• Erzeugen eines Programm-Code-Abschnittes zum
Verknüpfen der ersten codierten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels einer ausschließlichen oder-Operation;
• Erzeugen eines Programm-Code-Abschnittes zum Speichern der ersten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der ersten
Speicheradresse ;
• Erzeugen eines Programm-Code-Abschnittes zum Ermitteln einer zweiten Speicheradressen-Signatur basierend auf einer zweiten Speicheradresse;
• Erzeugen eines Programm-Code-Abschnittes zum
Verknüpfen der zweiten codierten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels einer ausschließlichen oder-Operation; und
• Erzeugen eines Programm-Code-Abschnittes zum Speichern der zweiten verknüpften codierten ein oder mehreren Zahlenwerte in einem Speicher an der zweiten
Speicheradresse
Verfahren gemäß Anspruch 21, aufweisend
• Erzeugen eines Programm-Code-Abschnittes zum Laden der ersten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der ersten Speicheradresse;
• Erzeugen eines Programm-Code-Abschnittes zum
Verknüpfen der geladenen ersten ein oder mehreren Zahlenwerte mit der ersten Speicheradressen-Signatur mittels der ausschließlichen oder-Operation;
• Erzeugen eines Programm-Code-Abschnittes zum Laden der zweiten codierten ein oder mehreren Zahlenwerte aus dem Speicher an der zweiten Speicheradresse; und
• Erzeugen eines Programm-Code-Abschnittes zum
Verknüpfen der geladenen zweiten ein oder mehreren Zahlenwerte mit der zweiten Speicheradressen-Signatur mittels der ausschließlichen oder-Operation.
23. Verfahren gemäß Anspruch 22,
wobei beim Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programm-Codes ein Fehler aufgetreten ist, ferner ein Programm-Code-Abschnitt zum Ermitteln erzeugt wird, ob bei dem Laden der ersten oder zweiten codierten ein oder mehreren Zahlenwerte ein Fehler aufgetreten ist, basierend auf den geladenen ersten und zweiten codierten ein oder mehreren Zahlenwerten, dem ersten Multiplikator und dem zweiten Multiplikator.
24. Verfahren gemäß einem der Ansprüche 20 bis 23,
• wobei der Programm-Code-Abschnitt zum Ermitteln der ersten Speicheradressen-Signatur derart erzeugt wird, dass die erste Speicheradressen-Signatur auf einer ersten Basisspeicheradresse und/oder der ersten
Speicheradresse basiert ist; und
• wobei der Programm-Code-Abschnitt zum Ermitteln der zweiten Speicheradressen-Signatur derart erzeugt wird, dass die zweite Speicheradressen-Signatur auf einer zweiten Basisspeicheradresse und/oder der zweiten Speicheradresse basiert ist.
25. Verfahren gemäß einem der Ansprüche 20 bis 24, aufweisend
• Erzeugen eines Programm-Code-Abschnittes zum
Decodieren eines ersten und zweiten codierten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten
Zahlenwertes; und • Erzeugen des Programm-Code-Abschnittes zum Auswählen des ersten Multiplikators und des zweiten
Multiplikators derart, dass ein Decodieren des codierten ersten und zweiten Zahlenwertes zu einem decodierten Zahlenwert mittels einer Differenz des codierten ersten und zweiten Zahlenwertes möglich ist.
Verfahren gemäß Anspruch 25,
• wobei beim Erzeugen des Programm-Code-Abschnittes zum Decodieren des codierten ersten und zweiten
Zahlenwertes zu einem decodierten Zahlenwert ferner ein Programm-Code-Abschnitt zum Verschieben der Ziffern des Ergebniswertes der Differenz des codierten ersten und zweiten Zahlenwertes in Richtung der Ziffernposition mit dem niedrigsten Wert erzeugt wird; und
• wobei der Programm-Code-Abschnitt zum Auswählen des ersten Multiplikators und des zweiten Multiplikators derart erzeugt wird, dass der erste Multiplikator und der zweite Multiplikator derart ausgewählt werden, dass das Decodieren des ersten und zweiten codierten Zahlenwertes zu einem decodierten Zahlenwert mittels der Differenz des ersten und zweiten codierten Zahlenwertes gefolgt von dem Verschieben der Ziffern möglich ist.
Verfahren gemäß einem der Ansprüche 20 bis 26, aufweisend Erzeugen eines Programm-Code-Abschnittes zum Korrigieren eines fehlerhaften decodierten Zahlenwertes mittels eines codierten ersten und zweiten Zahlenwertes, die jeweils dem decodierten Zahlenwert entsprechen.
Verfahren gemäß einem der Ansprüche 20 bis 27,
wobei der arithmetische Code ein arithmetischer Code mit
Signaturen ist.
29. Verfahren gemäß einem der Ansprüche 20 bis 28, wobei der arithmetische Code aufweist mindestens
Code aus einer Gruppe von Codes bestehend aus:
• einem AN-Code;
• einem ANB-Code;
• einem AND-Code;
• einem ANDmem-Code;
• einem ANBD-Code; und
• einem ANBDmem-Code .
Datenverarbeitungsanordnung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, aufweisend :
• einen Schaltkreis zum Ausführen von codiertem
Programm-Code ;
• einen ersten Anweisung-Ausführungs-Schaltkreis zum
Ausführen mindestens einer Anweisung des codierten Programm-Codes basierend auf ersten codierten ein oder mehreren Zahlenwerten, die mittels eines
arithmetischen Codes aufweisend einen ersten
Multiplikator codiert sind und ein oder mehreren
Operanden der mindestens einen Anweisung entsprechen;
• einen zweiten Anweisung-Ausführung-Schaltkreis zum
Ausführen der mindestens einen Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten, die mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind und den ein oder mehreren Operanden der mindestens einen Anweisung entsprechen; und
• einen Ermittlungs-Schaltkreis zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren
Ergebniswerten des Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Datenverarbeitungsanordnung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, aufweisend :
• einen Empfangs-Schaltkreis zum Empfangen von ersten codierten ein oder mehreren Ergebniswerten, eines ersten Multiplikators, zweiten codierten ein oder mehreren Ergebniswerten und eines zweiten
Multiplikators von dem Programm in einem Überprüfungs- Schaltkreis außerhalb des Programms;
• wobei der erste codierte Ergebniswert in dem Programm beim Ausführen zumindest einer Anweisung basierend auf ersten codierten ein oder mehreren Zahlenwerten ermittelt worden ist, wobei die ersten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator codiert sind;
• wobei der zweite codierte Ergebniswert in dem Programm beim Ausführen zumindest einer Anweisung basierend auf zweiten codierten ein oder mehreren Zahlenwerten ermittelt worden ist, wobei die zweiten codierten ein oder mehreren Zahlenwerte ein oder mehreren Operanden der zumindest einen Anweisung entsprechen und mittels des arithmetischen Codes aufweisend einen zweiten Multiplikator codiert sind; und
• einen Ermittlungs-Schaltkreis zum Ermitteln in dem
Überprüfungs-Schaltkreis, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf den ersten codierten ein oder mehreren Ergebniswerten und dem ersten Multiplikator und/oder basierend auf den zweiten ein oder mehreren Ergebniswerten und dem zweiten Multiplikator. 32. Datenverarbeitungsanordnung zum Erzeugen von codierten
Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, aufweisend: einen ersten Codierung-Programm-Code-Abschnitt- Erzeugungs-Schaltkreis zum Erzeugen eines Programm- Code-Abschnittes zum Codieren von ein oder mehreren Operanden mindestens einer Anweisung des Programms in erste codierte ein oder mehrere Zahlenwerte mittels eines arithmetischen Codes aufweisend einen ersten Multiplikator;
einen zweiten Codierung-Programm-Code-Abschnitt- Erzeugungs-Schaltkreis zum Erzeugen eines Programm- Code-Abschnittes zum Codieren der ein oder mehreren Operanden der mindestens einen Anweisung in zweite ein oder mehrere codierte Zahlenwerte mittels des
arithmetischen Codes aufweisend einen zweiten
Multiplikator;
einen ersten Anweisung-Ausführung-Programm-Code- Abschnitt-Erzeugungs-Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten;
einen zweiten Anweisung-Ausführung-Programm-Code- Abschnitt-Erzeugungs-Schaltkreis zum Erzeugen eines Programm-Code-Abschnittes zum Ausführen der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten; und
einen Ermittlung-Programm-Code-Abschnitt-Erzeugungs- Schaltkreis zum Erzeugen eines Programm-Code- Abschnittes zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf ersten ein oder mehreren Ergebniswerten des
Ausführens der mindestens einen Anweisung auf den ersten codierten ein oder mehreren Zahlenwerten und dem ersten Multiplikator und/oder basierend auf zweiten ein oder mehreren Ergebniswerten des
Ausführens der mindestens einen Anweisung auf den zweiten codierten ein oder mehreren Zahlenwerten und dem zweiten Multiplikator. Computerprogrammelement, das, wenn es von einem Prozessor ausgeführt wird, bewirkt, dass der Prozessor ein Verfahren zur Datenverarbeitung gemäß einem der Ansprüche 1 bis 29 ausführt .
PCT/EP2015/072585 2014-09-30 2015-09-30 Verfahren zur datenverarbeitung zum ermitteln, ob bei einer ausführung eines programms ein fehler aufgetreten ist und datenverarbeitungsanordnungen zum erzeugen von programm-code WO2016050857A1 (de)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102014114157.1 2014-09-30
DE102014114157.1A DE102014114157B4 (de) 2014-09-30 2014-09-30 Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code

Publications (1)

Publication Number Publication Date
WO2016050857A1 true WO2016050857A1 (de) 2016-04-07

Family

ID=54291264

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/EP2015/072585 WO2016050857A1 (de) 2014-09-30 2015-09-30 Verfahren zur datenverarbeitung zum ermitteln, ob bei einer ausführung eines programms ein fehler aufgetreten ist und datenverarbeitungsanordnungen zum erzeugen von programm-code

Country Status (2)

Country Link
DE (1) DE102014114157B4 (de)
WO (1) WO2016050857A1 (de)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP4266175A1 (de) * 2022-04-22 2023-10-25 Siemens Mobility GmbH Verfahren zum rechnergestützten betreiben einer speichereinheit und ausführen von applikationsprogrammen mit speicherüberprüfung auf speicherfehler
EP4266176A1 (de) * 2022-04-22 2023-10-25 Siemens Mobility GmbH Verfahren zum rechnergestützten betreiben einer speichereinheit und ausführen von applikationsprogrammen mit redundanter datenspeicherung

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE10219501A1 (de) * 2002-04-30 2003-11-27 Siemens Ag System und Verfahren zur Verbesserung von Fehlerbeherrschungsmassnahmen, insbesondere in Automatisierungssystemen
DE102007040721A1 (de) * 2006-12-08 2008-06-19 Technische Universität Dresden Datenverarbeitungsanordnung, Verfahren zur Datenverarbeitung, Computerprogrammelement und Überprüfungsanordnung für einen Speicher

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE10219501A1 (de) * 2002-04-30 2003-11-27 Siemens Ag System und Verfahren zur Verbesserung von Fehlerbeherrschungsmassnahmen, insbesondere in Automatisierungssystemen
DE102007040721A1 (de) * 2006-12-08 2008-06-19 Technische Universität Dresden Datenverarbeitungsanordnung, Verfahren zur Datenverarbeitung, Computerprogrammelement und Überprüfungsanordnung für einen Speicher

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
NAHMSUK OH, SUBHASISH MITRA, EDWARD J. MCCLUSKEY: "ED4I: Error detection by diverse data and duplicated instructions", IEEE TRANSACTIONS ON COMPUTERS, vol. 51, no. 2, 28 February 2002 (2002-02-28), US, pages 180 - 199, XP002751192, ISSN: 0018-9340 *

Also Published As

Publication number Publication date
DE102014114157B4 (de) 2016-11-03
DE102014114157A1 (de) 2016-03-31

Similar Documents

Publication Publication Date Title
DE102010037457B4 (de) Verfahren zur Datenverarbeitung zum Bereitstellen eines Wertes zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, Verfahren zum Erzeugen von Programm-Code, Datenverarbeitungsanordnungen zum Bereitstellen eines Wertes zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, Datenverarbeitungsanordnungen zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code
DE102014117971B4 (de) Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code
DE102006005817B4 (de) Fehlererkennungsvorrichtung für einen Adressdecoder und Vorrichtung zur Fehlererkennung für einen Adressdecoder
DE102015210651B4 (de) Schaltung und Verfahren zum Testen einer Fehlerkorrektur-Fähigkeit
EP1043641A2 (de) Fehlersicheres Automatisierungssystem mit Standard-CPU und Verfahren für ein fehlersicheres Automatisierungssystem
EP2631802B1 (de) Verfahren zur Speicherung und Propagation von Fehlerinforationen in Computer-Programmen
DE102004011450A1 (de) Anvisierte Fehlertoleranz durch spezielle CPU-Befehle
DE102011011333B4 (de) Lesen in Peripheriegeräte und schreiben aus Peripheriegeräten mit zeitlich getrennter, redundanter Prozessorausführung
DE102005054587A1 (de) Programmgesteuerte Einheit und Verfahren zum Betreiben derselbigen
DE102011119585A1 (de) Verbesserte skalierbare CPU für die codierte Ausführung von Software in hochabhängigen sicherheitsrelevanten Anwendungen
DE102014114157B4 (de) Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code
DE102007040721B4 (de) Datenverarbeitungsanordnung, Verfahren zur Datenverarbeitung, Computerprogrammelement und Überprüfungsanordnung für einen Speicher
DE112012004323T5 (de) Elektronisches Steuergerät
EP4200727B1 (de) Verfahren und einrichtung zur sicherung von zugriffen auf codierte variablen in einem computerprogramm
DE102005016051B4 (de) Speicherüberprüfungsvorrichtung und Verfahren zum Überprüfen eines Speichers
DE102004001651B4 (de) Verfahren und Prozessor zur automatischen Befehls-Betriebsartumschaltung zwischen N-Bit und 2N-Bit Befehlen unter Verwendung einer Paritätsüberprüfung
AT513533B1 (de) Verfahren zum Überprüfen von Daten mittels wenigstens zweier Prüfsummen
DE102013108073A1 (de) Datenverarbeitungsanordnung und verfahren zur datenverarbeitung
DE102013112020B4 (de) Verfahren und Vorrichtung zum Erkennen von Bitfehlern
DE102011103238A1 (de) Computer System, Computerimplementiertes Verfahren und Computerprogrammprodukt zum Bestimmen eines pessimistischen Zeitverhaltens eines Fehlertoleranzmechanismus
DE102022125477A1 (de) Ausführung-vor-ort-architektur mit integritätsüberprüfung
EP4181000A1 (de) Verfahren und rechenumgebung zum erstellen und anwenden eines prüfalgorithmus für rechenvorgänge
DE102022208087A1 (de) Verfahren zum Überprüfen einer Verarbeitung von Nutzdaten
DE102022105535A1 (de) Vorrichtung, Verfahren und System in Bezug auf Datenspeicherungselemente
DE102022111126A1 (de) Datenverarbeitungsvorrichtung und verfahren zum prüfen der integrität eines speichers

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 15778243

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 15778243

Country of ref document: EP

Kind code of ref document: A1