DE102014117971B4 - 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
DE102014117971B4
DE102014117971B4 DE102014117971.4A DE102014117971A DE102014117971B4 DE 102014117971 B4 DE102014117971 B4 DE 102014117971B4 DE 102014117971 A DE102014117971 A DE 102014117971A DE 102014117971 B4 DE102014117971 B4 DE 102014117971B4
Authority
DE
Germany
Prior art keywords
basic block
signature
program
block
basic
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Active
Application number
DE102014117971.4A
Other languages
English (en)
Other versions
DE102014117971A1 (de
Inventor
Christof Fetzer
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Silistra Systems De GmbH
Original Assignee
Technische Universitaet 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 Universitaet Dresden filed Critical Technische Universitaet Dresden
Priority to DE102014117971.4A priority Critical patent/DE102014117971B4/de
Priority to PCT/EP2015/078677 priority patent/WO2016087652A1/de
Publication of DE102014117971A1 publication Critical patent/DE102014117971A1/de
Application granted granted Critical
Publication of DE102014117971B4 publication Critical patent/DE102014117971B4/de
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/28—Error detection; Error correction; Monitoring by checking the correct order of processing
    • G—PHYSICS
    • G06—COMPUTING; 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/10—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's
    • G06F11/1004—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's to protect a block of data words, e.g. CRC or checksum
    • G—PHYSICS
    • G06—COMPUTING; 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/14—Error detection or correction of the data by redundancy in operation
    • G06F11/1479—Generic software techniques for error detection or fault masking
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/50—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
    • G06F21/52—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity ; Preventing unwanted data erasure; Buffer overflow
    • G06F21/54—Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity ; Preventing unwanted data erasure; Buffer overflow by adding security routines or objects to programs

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Computer Security & Cryptography (AREA)
  • General Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Software Systems (AREA)
  • Quality & Reliability (AREA)
  • Computer Hardware Design (AREA)
  • Stored Programmes (AREA)

Abstract

Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, das Verfahren aufweisend: • Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Ermitteln einer Basisblock-Signatur zumindest des zweiten Basisblocks aus einer Referenz-Überprüfungsinformation des zweiten Basisblocks; • Ermitteln von Überprüfungsinformation zumindest des ersten Basisblocks während der Ausführung des ersten Basisblocks basierend auf der Basisblock-Signatur des ersten Basisblocks, wobei die Basisblock-Signatur des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und zumindest der Basisblock-Signatur des zweiten Basisblocks, gemäß der Referenz-Überprüfungsinformation zumindest des zweiten Basisblocks, ermittelt wird; • Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation; • Setzen der Referenz-Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.

Description

  • Die Erfindung betrifft Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, 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, dass Standard-Hardware oder Massen-Hardware (engl.: „Commodity Hardware”) immer weniger zuverlässig wird aufgrund der kontinuierlich steigenden Integrationsdichte und schrumpfenden Strukturbreiten von neuen Generationen von integrierten Schaltkreisen.
  • Um Hardwarefehler bei Ausführung von Software zu erkennen, kann die Hardware repliziert werden, die Mikroprozessor-Architektur verändert werden oder es können zusätzliche Schaltkreise hinzufügt werden, z. B. zur Überprüfung.
  • 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.
  • Weiterhin kann ein Prozessor in eine unsichere und eine sichere Prozessorkomponente aufgeteilt werden. 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. Jedoch können auch in der sicheren Prozessorkomponente Fehler auftreten, Fehler sind lediglich weniger wahrscheinlich oder seltener.
  • Ferner ist es möglich, einen Arbeitsspeicher, einen Prozessor-Cache oder Register dediziert zu schützen.
  • Ferner können verwendete Hardware-basierte Lösungen zum Ermitteln von Hardware-Fehlern um eine Größenordnung langsamer als Standard-Hardware sein. Daher werden aus Kostendruckgründen immer mehr kritische System auf unzuverlässiger Standard-Hardware aufgebaut werden oder diese verwenden. Jedoch zeigt Standard-Hardware nicht nur Fehler-Stopp-Verhalten (englisch: Fail-Stop), sondern auch schwieriger zu detektierende und zu maskierende Silent Data Corruptions (SDC), d. h. sie erzeugt eine fehlerhafte Ausgabe anstatt abzustürzen.
  • Software-Ansätze zur Erkennung von Hardware-Fehlern können replizierte Ausführung und Vergleich (englisch: Voting) der erzielten Ergebnisse sein. Die Redundanz kann auf der Informations-, Zeit- oder Ausführungsebene hinzugefügt werden. Die zu schützende Software kann während oder vor der Compilierung verändert werden.
  • Eine weitere mögliche Lösung zum Detektieren von Hardware-Fehlern in Software ist die Verwendung von arithmetischen Codes, z. B. von AN-, ANB- oder ANBmem-Codes. Mit der Hilfe dieser Codes können codierte Programme erzeugt werden. Diese Codes detektieren Hardware-Fehler unabhängig von dem tatsächlichen Fehler-Modus der zugrundeliegenden Hardware.
  • Jedoch schützen arithmetischen Codes lediglich den Datenfluss des codierten Programmes. Fehler, die den Kontrollfluss (oder Ablauffluss) betreffen werden nur erkannt, wenn ein ungültig codiertes Ergebnis resultiert, was nicht immer der Fall ist. Ferner haben Messungen gezeigt, dass mit einfachen arithmetischen Codes, z. B. AN-Codes, codierte Programme zu hohe Raten von nicht-erkannten stillen Daten-Fehlern (englisch: „Silent Data Corruption”, SDC) enthalten. Bei Verwendung von arithmetische Codes, z. B. ANB- und ANBmem-Codes, bei denen auch vertauschte Operationen zu ungültigen Code-Worten führen, erhöht sich die Laufzeit des Ausführens eines mit AN-, ANB- oder ANBmem-Codes codierten Programms erheblich. Beispielsweise kann sich die Laufzeit eines mit ANB- oder ANBD-Codes codierten Programms sich um bis das 300-fache verlangsamen.
  • Deswegen ist es wünschenswert einen eigenständigen Schutz des Programms vor einer ungewollten Änderung des Kontrollflusses zu haben, ausgelöst z. B. durch unerwartet auftretende Zustandsänderungen in der Hardware, auch weicher Fehler (englisch: „Soft Errors”) oder Einmalige-Ereignis-Störung (englisch: „Single Event Upset”, SEU) genannt. Ein weicher Fehler kann zu einem stillen Daten-Fehler (englisch: „Silent Data Corruption”, SDC), zu einem detektierten nicht wiederherstellbaren Fehler (englisch: „Detected Unrecoverable Error”, DUE) führen oder keinen Einfluss auf das Programm haben.
  • Fehler im Kontrollfluss können an beliebigen Stellen innerhalb eines Programms auftreten. Es kann eine falsche Programm-Anweisung aufgerufen werden, die falsche Abzweigung aufgerufen werden oder zu einer falschen Position oder Funktion innerhalb oder außerhalb des Programms gesprungen werden. Wenn zu einer Position außerhalb des Programms, anders ausgedrückt zu einer Speicherposition außerhalb der Speicherregion, die die Programm-Anweisungen enthält, gesprungen wird, kann dies mittels Schutzmechanismen moderner Prozessoren detektiert werden. Wenn von dem vorgesehenen Kontrollfluss abgewichen wird, aber weiterhin Code des Programms ausgeführt wird, kann dies von den Schutzmechanismen moderner Prozessoren nicht detektiert werden.
  • Wenn der Kontrollfluss eines ausgeführten Programms visualisiert wird, können die ausgeführten Blöcke einen oder mehrere Vorgänger-Blöcke haben. Die Ausführung eines Blocks sollte immer mit der ersten Programm-Anweisung starten, jedoch kann bei einem Fehler zu einer beliebigen Anweisung des Blocks gesprungen werden, auch in der Mitte oder am Ende des Blocks. Der Speicherplatz eines auszuführenden Programms oder einer Anwendung kann dynamisch während Ausführung zugewiesen werden. Nicht alle verwendeten Datenstrukturen oder aufzurufenden Funktionen müssen zum Zeitpunkt des Compilierens statisch bekannt sein. Beispielsweise kann aufgrund eines falschen Funktionszeigers die falsche Funktion aufgerufen werden.
  • Weiterhin sollten alle diese Fehler erkannt werden, unabhängig ob der Fehlererkennungs-Ansatz in Hardware, in Software oder als hybrides System implementiert ist.
  • Eingebettete Systeme werden zunehmend mit dem Internet verbunden, z. B. sind heutzutage die Computer von Autos und Flugzeugen mit einem externen Netzwerk wie beispielsweise dem Internet verbunden. Dabei sollte es eine logische Trennung zwischen dem externen Netzwerk wie beispielsweise dem Internet und dem sicherheitskritischen eingebetteten System oder Teilsystem geben. Jedoch ist eine logische sichere Trennung nicht immer einfach. Schadprogramme können den Kontrollfluss eines Programms beliebig verändern, z. B. mittels eines Puffer-Überlaufs.
  • Die Druckschrift Galla, T. u. a. ”Control Flow Monitoring for a Time-Triggered Communication Controller”, 10th European Workshop an Dependable Computing (EWDC-10), Mai 1999 offenbart ein Kontrollflussüberwachtungsschema, bei dem Referenzsignaturen für Basisblöcke und Überprüfungsbefehle in den Programmablauf eingebaut werden, wobei ein Überprüfungsbefehl überprüft, ob die Signatur eines Basisblocks bei seiner Ausführung mit der jeweiligen Referenzsignatur übereinstimmt.
  • In der Druckschrift Sosnowski, J., ”Detection of control flow errors using signature and checking instructions”, Test Conference, 1988, Proceedings, New Frontiers in Testing, International, September 1988, S. 81–88 ist eine Herangehensweise zum Detektieren von Kontrollflussfehlern beschrieben, bei der Signaturen an vorgegebenen Punkten in einem Programm anhand von Referenzsignaturen überprüft werden.
  • Die Druckschrift Schütte, M. A. u. a., ”Processor Control Flow Monitoring Using Signatured Instructions Streams”, Computers, IEEE Transactions on, Vol. C-36, März 1987, S. 264–276 beschreibt ein Verfahren zum Detektieren von Kontrollflussfehlern, bei dem für gültige Instruktionsfolgen Signaturen am Ende der Instruktionsfolgen gespeichert werden, mit denen zur Laufzeit erzeugte Signaturen verglichen werden, um Fehler zu detektieren.
  • 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.
  • Ein Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann ein Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks aufweisen, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweisen kann, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann das Verfahren ein Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks und ein Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation, aufweisen.
  • Es ist in diesem Zusammenhang darauf hinzuweisen, dass nicht jede Basisblock-Signatur notwendigerweise die Signatur von mindestens einem nachfolgenden Basisblock aufweisen muss. So weist beispielsweise der letzte Basisblock in einem Programm keine solche Signatur auf, ebenso wenig wie ein Basisblock mit einer Rücksprung-Anweisung, anders ausgedrückt mit einer Rückkehr(Return)-Anweisung.
  • In dem Fall eines Basisblocks mit einer Rücksprung-Anweisung kann beispielsweise folgende Vorgehensweise vorgesehen sein: Es wird zunächst die Signatur des Basisblocks geprüft, welcher ausgeführt wird, nachdem die Funktion bei der Aufruf-Anweisung zurückkehrt. Dies bedeutet, dass der Nachfolger einer Aufruf-Anweisung der aufgerufene Basisblock ist und das der Basisblock mit der Anweisung startet, die der Aufruf-Anweisung in dem Programm folgt (diese Anweisung wird ausgeführt, nach dem Zurückkehren von der aufgerufenen Funktion). Nach dem Aufruf wird die zweite Signatur auf dem Stapel innerhalb des Überprüfungs-Schaltkreises (der auch als Steuerungs-Ablauf-Überprüfungs-Schaltkreis (control flow checker, CFC) bezeichnet werden kann) gespeichert und von dort wieder gelesen auf das Rückkehren aus der Funktion hin. Die zweite Signatur wird dann als der erwartete Wert verwendet. Dies ermöglicht die Vermeidung von Korrekturwerten (beispielsweise Signaturen) für Rückkehr-Basisblöcke. Somit haben Signaturen von Basisblöcken mit Rückkehr-Anweisungen keinen Nachfolger.
  • Ein Basisblock ist eine Sequenz von Programm-Anweisungen (in anderen Worten: Anweisungen oder Instruktionen) mit genau einem Einsprungpunkt (am Beginn der Sequenz) und genau einem Austrittspunkt am Ende der Sequenz. Der Austrittspunkt ist ein bedingter, unbedingter Sprung oder ein Rücksprung zur aufgerufenen Funktion. Funktionsaufrufe können Austrittspunkte oder eine einfache Programm-Anweisungen innerhalb der Sequenz darstellen. Beim Ausführen eines jeweiligen Basisblocks kann mit einer vorbestimmten ersten Anweisung begonnen und die eine oder die mehreren Anweisungen sequentiell ausgeführt werden.
  • Die Referenz-Überprüfungsinformation des mindestens einen Basisblocks kann vor Ausführung des jeweiligen Basisblocks ermittelt werden.
  • Anschaulich kann Referenz-Überprüfungsinformation ermittelt werden, z. B. vor Ausführung des Programms, und bei Ausführung des Programms kann die Überprüfungsinformation ermittelt werden. Beide können miteinander verglichen werden, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist. Sowohl die Referenz-Überprüfungsinformation als auch die Überprüfungsinformation basieren auf den Basisblock-Signaturen, wobei neben der Signatur eines jeweils betrachteten Basisblocks auch die Signatur mindestens eines nachfolgenden Basisblocks berücksichtigt wird. Die Signatur eines jeweiligen Basisblocks kann auf den Programm-Anweisungen des Basisblocks bzw. auf Signaturen, Identifikatoren oder allgemein Werten basieren, die den Programm-Anweisungen zugeordnet sind oder aus ihnen ermittelt werden können.
  • In verschiedenen Ausführungsbeispielen kann die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks, z. B. einer Programm-Anweisungs-Signatur für die mindestens eine Anweisung, und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt werden, der dem jeweiligen Basisblock unmittelbar nachfolgt, z. B. von allen unmittelbar nachfolgenden Basisblöcke oder nur von dem Basisblock, der tatsächlich ausgeführt werden soll.
  • In verschiedenen Ausführungsformen können sowohl Fehler des Kontrollflusses innerhalb eines Basisblocks als auch Fehler zwischen Basisblöcken detektiert werden.
  • Beim Ermitteln der Basisblock-Signatur kann, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt werden und ein Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock ermittelt werden.
  • Der beliebige Wert kann als Basisblock-Signatur gewählt und der Korrekturwert ermittelt werden, wenn die Referenz-Überprüfungsinformation ermittelt wird.
  • Anschaulich können beim Ermitteln der Referenz Überprüfungsinformation nachfolgende Basisblock-Signaturen unbekannt sein und auf einen beliebigen Wert gesetzt werden. Beim Ermitteln der Überprüfungsinformation können die nachfolgenden Basisblock-Signaturen bekannt sein, z. B. als die Basisblock-Signatur oder der beliebige Wert der bereits ermittelten Referenz-Überprüfungsinformation. Wenn beim Ermitteln der Überprüfungsinformation eine Basisblock-Signatur ermittelt wird, die in der Referenz-Überprüfungsinformation auf einen beliebigen Wert gesetzt worden ist, sollte diese Basisblock-Signatur in der Überprüfungsinformation mittels des Korrekturwerts korrigiert werden.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion eine kryptographische Signaturfunktion sein.
  • Ferner kann die kryptographische Signaturfunktion eine kryptographische Hash-Funktion sein.
  • Weiterhin kann die kryptographische Hash-Funktion eine der folgenden Funktionen sein: MD4, MD5, und dergleichen.
  • Die Signaturfunktion kann ermittelt werden, indem die jeweilige Programm-Anweisung, z. B. eine Signatur der jeweiligen Programm-Anweisung, oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft wird.
  • So kann die Basisblock-Signatur akkumulierend ermittelt werden. Ferner kann die Signaturfunktion so gewählt werden, dass sie andere Ergebnisse liefert, je nachdem in welcher Reihenfolge die Programm-Anweisungen und/oder Basisblock-Signaturen berücksichtigt werden.
  • In verschiedenen Ausführungsbeispielen kann ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  • Weiterhin kann ein Akkumulator-Wert mit einem Initialisierungs-Wert initialisiert und ein erwarteter Wert auf die Referenz-Überprüfungsinformation des Basisblocks gesetzt werden, der als nächstes ausgeführt werden soll.
  • Das Initialisieren des Akkumulator-Werts und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation kann gemeinsam atomar ausgeführt werden.
  • Anschaulich kann die Überprüfungsinformation den Akkumulator aufweisen, der basierend auf den Programm-Anweisungen und den für die nachfolgenden Basisblöcke bereits als Referenz-Überprüfungsinformation ermittelten Basisblock-Signaturen aktualisiert werden kann. Die Referenz-Überprüfungsinformation kann die Basisblock-Signaturen inklusive dem beliebigen Wert und der Korrekturinformation aufweisen. Die Signaturen, Identifikatoren oder Werte, die jeweils einer Programm-Anweisung zugeordnet sein können und mittels derer die Basisblock-Signaturen der Überprüfungsinformation und der Referenz-Überprüfungsinformation ermittelt werden, können anschaulich eine eigene Information darstellen, z. B. abgespeichert oder in den Programm-Code eingefügt sein.
  • In verschiedenen Ausführungsformen kann das Verfahren mittels des Akkumulators und des erwarteten Werts, z. B. mittels zweier Register, effizient implementiert werden.
  • Der Akkumulator-Wert kann basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock aktualisiert werden, wenn der jeweilige Basisblock ausgeführt wird.
  • Ferner kann der Akkumulator-Wert basierend auf dem Korrekturwert aktualisiert werden.
  • Das Aktualisieren des Akkumulator-Werts mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock kann ein Aktualisieren des Akkumulator-Werts mit der Basisblock-Signatur des nachfolgenden Basisblock aufweisen, der als nächstes ausgeführt werden soll. Ferner kann das Aktualisieren des Akkumulator-Werts ein Aktualisieren mit den Basisblock-Signaturen aller unmittelbar nachfolgenden Basisblöcke aufweisen. Mit welchen nachfolgenden Basisblock-Signaturen aktualisiert wird, kann von einer Art der Programm-Sprunganweisung abhängen, z. B. unterschiedlich sein je nachdem, ob es sich um eine bedingte Programmsprung-Anweisung, einen Funktionsaufruf, einen Funktions-Aufruf mittels Funktionszeiger oder einen Rücksprung aus einer Funktion handelt.
  • Ferner kann der Akkumulator-Wert der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert werden, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird.
  • In verschiedenen Ausführungsbeispielen kann ein Fehler detektiert werden, bevor ein falscher Basisblock ausgeführt wird.
  • Zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, kann der Akkumulator-Wert basierend auf dem erwarteten Wert überprüft werden.
  • Es kann ermittelt werden, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen.
  • In verschiedenen Ausführungsformen kann das Ermitteln der Referenz-Überprüfungsinformation in einem Überprüfungs-Schaltkreis durchgeführt werden.
  • Die ermittelte Überprüfungsinformation, z. B. der Akkumulator, kann an einen Überprüfungsschaltkreis übermittelt werden zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf der Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Der Überprüfungs-Schaltkreis kann außerhalb des Programms implementiert sein.
  • Der Überprüfungs-Schaltkreis kann in sicherer Hardware implementiert sein.
  • Ein Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann ein Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms aufweisen, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann das Verfahren ein Empfangen von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis, wobei die Überprüfungsinformation auf der Basisblock-Signatur des jeweiligen Basisblocks basiert, und ein Ermitteln in dem Überprüfungsschaltkreis, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz-Überprüfungsinformation, aufweisen.
  • Die Referenz-Überprüfungsinformation des mindestens einen Basisblocks kann vor Ausführung des jeweiligen Basisblocks ermittelt werden.
  • In verschiedenen Ausführungsbeispielen kann die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt werden, der dem jeweiligen Basisblock unmittelbar nachfolgt.
  • Beim Ermitteln der Basisblock-Signatur kann, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt werden und ein Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock ermittelt werden.
  • Ferner kann beim Ermitteln der Referenz-Überprüfungsinformation der beliebige Wert als Basisblock-Signatur gewählt und der Korrekturwert ermittelt werden.
  • Die Signaturfunktion kann eine kryptographische Signaturfunktion sein.
  • Die kryptographische Signaturfunktion kann eine kryptographische Hash-Funktion sein.
  • In verschiedenen Ausführungsbeispielen kann die kryptographische Hash-Funktion eine der folgenden Funktionen sein: MD4, MD5, und dergleichen.
  • Die Signaturfunktion kann ermittelt werden, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft werden.
  • Es kann ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  • In verschiedenen Ausführungsbeispielen kann ein Akkumulator-Wert mit einem Initialisierungs-Wert initialisiert werden und eine erwarteter Wert auf die Referenz-Überprüfungsinformation des Basisblocks gesetzt werden, der als nächstes ausgeführt werden soll.
  • Das Initialisieren des Akkumulator-Werts und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation kann gemeinsam atomar ausgeführt werden.
  • Ferner kann der Akkumulator-Wert basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock aktualisiert werden, wenn der jeweilige Basisblock ausgeführt wird.
  • Weiterhin kann der Akkumulator-Wert basierend auf dem Korrekturwert aktualisiert werden.
  • Das Aktualisieren des Akkumulator-Werts basierend auf der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock kann ein Aktualisieren des Akkumulator-Werts mit der Basisblock-Signatur des nachfolgenden Basisblock aufweisen, der als nächstes ausgeführt werden soll.
  • Wobei der Akkumulator-Wert mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert wird, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird.
  • In verschiedenen Ausführungsformen kann der Akkumulator-Wert an den Überprüfungsschaltkreis übermittelt werden und der Akkumulator-Werts basierend auf dem erwarteten Wert überprüft werden, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
  • Es kann ermittelt werden, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen.
  • Der Überprüfungs-Schaltkreis kann in sicherer Hardware implementiert sein.
  • Ein Verfahren zur Datenverarbeitung zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann ein Erzeugen eines Programm-Code-Abschnittes aufweisen zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Weiterhin kann das Verfahren ein Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks und ein Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation, aufweisen.
  • Der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation, kann derart erzeugt werden, dass die Referenz-Überprüfungsinformation des mindestens einen Basisblocks vor Ausführung des jeweiligen Basisblocks ermittelt wird.
  • Der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation und der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation können derart erzeugt werden, dass die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt wird, der dem jeweiligen Basisblock unmittelbar nachfolgt.
  • Der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation kann derart erzeugt werden, dass beim Ermitteln der Basisblock-Signatur, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt wird und ein Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock ermittelt wird.
  • Der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation kann derart erzeugt werden, dass der beliebige Wert als Basisblock-Signatur gewählt und der Korrekturwert ermittelt wird.
  • Ferner können der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation und der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass die Signaturfunktion eine kryptographische Signaturfunktion ist.
  • In verschiedenen Ausführungsbeispielen können der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation und der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass die kryptographische Signaturfunktion eine kryptographische Hash-Funktion ist.
  • Die kryptographische Hash-Funktion kann eine der folgenden Funktionen sein: MD4, MD5, und dergleichen.
  • Weiterhin können der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation und der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass die Signaturfunktion ermittelt wird, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft wird.
  • In verschiedenen Ausführungsformen kann der Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, derart erzeugt werden, dass ermittelt wird, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  • Ferner kann der Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, derart erzeugt werden, dass ein Akkumulator-Wert mit einem Initialisierungs-Wert initialisiert wird und ein erwarteter Wert auf die Referenz-Überprüfungsinformation des Basisblocks gesetzt wird, der als nächstes ausgeführt werden soll.
  • Das Initialisieren des Akkumulator-Werts und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation können gemeinsam atomar ausgeführt werden.
  • Weiterhin kann Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass der Akkumulator-Wert basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock aktualisiert wird, wenn der jeweilige Basisblock ausgeführt wird.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass der Akkumulator-Wert basierend auf dem Korrekturwert aktualisiert wird.
  • Ferner kann der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass der Akkumulator-Wert mit der Basisblock-Signatur des nachfolgenden Basisblock aktualisiert wird, der als nächstes ausgeführt werden soll.
  • Der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation kann derart erzeugt werden, dass der Akkumulator-Wert mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert wird, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, derart erzeugt werden, dass der Akkumulator-Wert basierend auf dem erwarteten Wert überprüft wird, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
  • Ferner kann der Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, derart erzeugt werden, dass ermittelt wird, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation derart erzeugt werden, dass die Referenz-Überprüfungsinformation in einem Überprüfungs-Schaltkreis ermittelt wird.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass die ermittelte Überprüfungsinformation an den Überprüfungsschaltkreis übermittelt wird zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf der Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Der Überprüfungs-Schaltkreis kann außerhalb des Programms implementiert sein.
  • Ferner kann der Überprüfungs-Schaltkreis in sicherer Hardware implementiert sein.
  • Eine Vorrichtung zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann einen Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis aufweisen, der eingerichtet ist zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann die Vorrichtung einen Überprüfungsinformation-Ermittlungs-Schaltkreis aufweisen, der eingerichtet ist zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks. Ferner kann die Vorrichtung einen Überprüfungsschaltkreis aufweisen, der eingerichtet ist zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Eine Vorrichtung zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann einen Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis aufweisen, der eingerichtet ist zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks und die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Die Vorrichtung kann ferner einen Empfangs-Schaltkreis aufweisen, der eingerichtet ist zum Empfangen von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis, wobei die Überprüfungsinformation auf der Basisblock-Signatur des jeweiligen Basisblocks basiert. Ferner kann die Vorrichtung einen Überprüfungsschaltkreis aufweisen, der eingerichtet ist zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Eine Vorrichtung zur Datenverarbeitung zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, kann einen Referenz-Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis aufweisen, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Die Vorrichtung kann ferner einen Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis aufweisen, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks. Weiterhin kann die Vorrichtung einen Überprüfungs-Code-Abschnitt-Erzeugungs-Schaltkreis aufweisen, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Ausführungsbeispiele der Erfindung sind in den Figuren dargestellt und werden im Weiteren näher erläutert.
  • 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.
  • 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.
  • 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.
  • 4 zeigt eine Datenverarbeitungsanordnung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel.
  • 5 zeigt eine Datenverarbeitungsanordnung zum Ermitteln, ob in einer Programmausführung ein Fehler aufgetreten ist, gemäß einem weiteren Ausführungsbeispiel.
  • 6 zeigt eine Datenverarbeitungsanordnung zum Erzeugen von Programm-Code zum Ermitteln, ob in einer Programmausführung ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel.
  • 7 zeigt eine Datenverarbeitungsanordnung gemäß einem Ausführungsbeispiel.
  • 8 zeigt eine Darstellung des Kontrollflusses zwischen Basisblöcken gemäß einem Ausführungsbeispiel.
  • 9 zeigt eine Darstellung des Kontrollflusses zwischen Basisblöcken gemäß einem weiteren Ausführungsbeispiel.
  • 10 zeigt eine Darstellung des Kontrollflusses zwischen Basisblöcken gemäß noch einem weiteren einem Ausführungsbeispiel.
  • 11 zeigt eine Datenverarbeitungsanordnung gemäß einem weiteren Ausführungsbeispiel.
  • 12 zeigt eine Datenverarbeitungsanordnung gemäß noch einem weiteren Ausführungsbeispiel.
  • 13 zeigt eine Datenverarbeitungsanordnung gemäß noch einem weiteren Ausführungsbeispiel.
  • 14 zeigt eine Datenverarbeitungsanordnung gemäß noch einem weiteren Ausführungsbeispiel.
  • 15 zeigt ein Diagramm zum Rechenzeitvergleich von Verfahren gemäß einem Ausführungsbeispiel.
  • 1 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. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet.
  • Die Programm-Anweisungen innerhalb eines Basisblocks können eine nach der anderen abgearbeitet werden, anders ausgedrückt sequentiell abgearbeitet werden, bis die letzte Programm-Anweisung des Basisblocks erreicht werden kann. Diese letzte Programm-Anweisung kann den Kontrollfluss des Programme ändern und wird daher als Programm-Sprunganweisung bezeichnet. Eine Anweisung innerhalb eines Basisblocks kann nicht Ziel einer Programm-Sprunganweisung oder irgendeiner anderen Anweisung sein, die den Kontrollfluss des Programms ändern kann. Die Ausführung eines Basisblocks kann immer mit der ersten Programm-Anweisung innerhalb des Basisblocks starten, anders ausgedrückt kann ausschließlich zu derselben ersten Anweisung des Basisblocks gesprungen werden.
  • Anschaulich kann eine Programm-Sprunganweisung eine Abzweigung implementieren, beispielsweise eine Schleife, eine bedingte Anweisung, z. B. eine „wenn ... dann ... sonst”-Anweisung, oder eine Auswahl (englisch: Switch)-Anweisung.
  • Eine Programm-Sprunganweisung kann ferner einen Sprung an eine andere Position des Programms implementieren, z. B. bei Rückkehr aus einem Basisblock oder einer Funktion, bei Aufruf einer internen Funktion.
  • Ein Sprung an eine andere Position eines Programms kann ohne Einschränkung der Allgemeinheit als Sprung zu einem anderen Basisblock angesehen werden. Anschaulich können die Programm-Anweisungen vor Aufruf der anderen Programm-Position als ein erster Basisblock angesehen werden, der mit Aufruf der anderen Programm-Position endet. Die Programm-Anweisungen an der anderen Programm-Position können als ein zweiter, unmittelbar nachfolgender Basisblock angesehen werden. Der zweite Basisblock kann mit einer Programm-Sprunganweisung an eine weitere andere Programm-Position enden. Im Fall eines Funktionsaufrufs kann der zweite Basisblock mit einer Programm-Sprunganweisung zurück zu einer Programm-Anweisung enden, die in dem Programm dem Funktionsaufruf unmittelbar nachfolgt. Diese Anweisung kann einer ersten Programm-Anweisung eines dritten Basisblocks entsprechen. Dem zweiten Basisblock können weitere zweite Basisblöcke folgen bevor zurück in den dritten Basisblock gesprungen wird.
  • In 102 kann Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks ermittelt werden. Die Basisblock-Signatur kann eine Signatur oder einen Identifikator des jeweiligen Basisblocks und die Signatur oder den Identifikator von mindestens einem nachfolgenden Basisblock aufweisen. Der mindestens eine nachfolgende Basisblock kann dem jeweiligen Basisblock unmittelbar nachfolgen.
  • In verschiedenen Ausführungsbeispielen kann eine Basisblock-Signatur auf der Signatur eines Basisblocks und auf der Signatur der ein oder mehreren nachfolgenden Basisblöcke, z. B. auf einer Basisblock-Signatur eines oder mehrerer der ein oder mehreren unmittelbar nachfolgenden Basisblöcke, z. B. aller der ein oder mehreren unmittelbar nachfolgenden Basisblöcke, basieren. Beim Ermitteln der Basisblock-Signatur kann die Reihenfolge der mindestens einen Anweisung und/oder der ein oder mehreren unmittelbar nachfolgenden Basisblöcke berücksichtigt werden.
  • Durch Berücksichtigung der Basisblock-Signatur des jeweiligen unmittelbaren mindestens einen Nachfolgers können in die Basisblock-Signatur des Basisblocks, mit dem die Ausführung eines Programms startet, die Basisblock-Signaturen aller nachfolgenden Basisblöcke oder zumindest aller nach einer Programm-Verzweigung folgenden Basisblöcke mit einbezogen werden. Nach einer Programm-Verzweigung können die ein oder mehreren Programm-Anweisungen oder Basisblöcke nachfolgen, die abhängig von einer Bedingung, z. B. abhängig von dem Ergebnis der Auswertung der Bedingung, z. B. basierend auf Daten, ausgeführt werden sollen.
  • In 104 kann Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks ermittelt werden, basierend auf der Basisblock-Signatur des jeweiligen Basisblocks.
  • Anschaulich können sowohl die Referenz-Überprüfungsinformation als auch die Überprüfungs-Information basierend auf der Basisblock-Signatur des jeweiligen Basisblocks ermittelt werden, also basierend auf der Signatur des jeweiligen Basisblocks, z. B. der Signatur der Anweisungen des jeweiligen Basisblocks, und der Basisblock-Signatur von ein oder mehreren unmittelbar nachfolgenden Basisblöcken, so dass die Referenz-Überprüfungsinformation und die Überprüfungsinformation miteinander verglichen werden können.
  • In 106 kann ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der bei Ausführung ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Anschaulich kann ermittelt werden, dass ein Fehler aufgetreten ist, wenn die ermittelte Überprüfungsinformation und die Referenz-Überprüfungsinformation nicht übereinstimmen. Wenn die Überprüfungsinformation und die Referenz-Überprüfungsinformation übereinstimmen, kann davon ausgegangen werden, dass bei Ausführung des Programms kein Fehler aufgetreten ist.
  • Wenn z. B. aufgrund eines Fehlers oder einer Manipulation zu einer falschen Position, z. B. in einen falschen Zweig des Programms gesprungen wird, kann dieser Fehler am Ende des nächsten Basisblocks detektiert werden. Dann können die ermittelte Basisblock-Signatur und die Basisblock-Signatur der Referenz-Information nicht übereinstimmen, z. B. mit hoher Wahrscheinlichkeit nicht miteinander übereinstimmen.
  • In verschiedenen Ausführungsbeispielen kann die Referenz-Überprüfungsinformation des mindestens einen Basisblocks vor Ausführung des jeweiligen Basisblocks ermittelt werden.
  • Anschaulich kann die Überprüfungsinformation während der Ausführung des jeweiligen Basisblocks ermittelt werden und die Referenz-Überprüfungsinformation kann vor der Ausführung des jeweiligen Basisblocks ermittelt werden. Beispielsweise kann die Referenz-Überprüfungsinformation vor der Ausführung eines Programms, z. B. beim Laden des Programms mittels eines Interpreters, beim Kompilieren des Programms oder bei der Ausführung des Programms, z. B. bei einem redundanten Ausführen des Programms, ermittelt werden. Die Referenz Überprüfungsinformation kann auch manuell in das Programm eingefügt werden.
  • Die Referenz-Überprüfungsinformation kann einmalig ermittelt und gespeichert oder in den geschützten Programm-Code eingefügt werden. Die Überprüfungsinformation kann bei jeder Programm-Ausführung ermittelt werden.
  • In verschiedenen Ausführungsbeispielen kann die Referenz-Überprüfungsinformation ermittelt werden, bevor die Ausführung des jeweiligen Basisblocks endet, während der die Überprüfungsinformation ermittelt wird. Die Referenz-Überprüfungsinformation kann ferner ermittelt werden, bevor die Referenz-Überprüfungsinformation und die Überprüfungsinformation miteinander verglichen werden, zum Ermitteln, ob ein Fehler aufgetreten ist.
  • In verschiedenen Ausführungsbeispielen kann die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt werden.
  • Anschaulich kann ein erster Basisblock beispielsweise zwei nachfolgende Basisblöcke aufweisen. Die Basisblock-Signatur des ersten Basisblocks kann mittels der ein oder mehreren Anweisungen innerhalb des Basisblocks ermittelt werden, z. B. mittels einer Signatur der jeweiligen Anweisung ermittelt werden. Diese Signatur kann ein vorbestimmter Zahlenwert oder ein zufälliger Zahlenwert sein, der dem Befehlscode, auch Operations-Code (engl. opcode) genannt, einer jeweiligen Anweisung zugeordnet sein kann, oder kann aus dem Befehlscode einer jeweiligen Anweisung ermittelt werden. Weiterhin kann die Basisblock-Signatur mittels der Basisblock-Signatur des ersten nachfolgenden Basisblocks und/oder des zweiten nachfolgenden Basisblocks ermittelt werden. Die Basisblock-Signatur des ersten und/oder des zweiten nachfolgenden Basisblocks kann wiederum mittels der Anweisungen innerhalb des ersten oder zweiten nachfolgenden Basisblocks und mittels der jeweils nachfolgenden Basisblöcke ermittelt werden.
  • Die Signaturfunktion kann die bisher ermittelte Basisblock-Signatur mit der Signatur einer nächsten nachfolgenden Anweisung verknüpfen. Weiterhin kann die Signaturfunktion die bisher ermittelte Basisblock-Signatur und eine Basisblock-Signatur eines unmittelbar nachfolgenden Basisblocks miteinander verknüpfen, z. B. eines als nächstes auszuführenden Basisblocks.
  • In verschiedenen Ausführungsbeispielen können zum Ermitteln der Referenz-Überprüfungsinformation und der Überprüfungsinformation dieselbe Signaturfunktion verwendet werden und den Programm-Anweisungen dieselben Signaturen zugewiesen werden.
  • Wenn die eine oder mehreren Anweisungen innerhalb eines Basisblocks unbekannt sind, z. B. bei einem Aufruf einer Programm-Funktion, z. B. einer externen Funktion deren Programm-Code unbekannt sein kann, kann diesem Basisblocks als Ganzes eine Signatur zugewiesen werden, z. B. eine vorbestimmte Signatur oder basierend auf einem Namen bzw. einer Adresse, z. B. dem Namen oder der Adresse der Programm-Funktionsanweisung. Die Basisblock-Signatur kann dann diese Signatur und die Basisblock-Signatur des nachfolgenden Basisblocks aufweisen.
  • In verschiedenen Ausführungsformen kann für jede Programm-Anweisung, die sich von einer anderen Programm-Anweisung unterscheidet, eine andere Signatur oder ein anderer Identifikator gewählt oder ermittelt werden. Beispielsweise kann für jeden Befehlscode, der sich von einem anderen Befehlscode unterscheidet, eine andere Signatur oder ein anderer Identifikator gewählt oder ermittelt werden. Die Signatur oder der Identifikator kann ein Zahlenwert sein, z. B. eine ganze Zahl oder eine Zufallszahl.
  • In verschiedenen Ausführungsformen kann die Signatur einer Programm-Anweisung ferner von einem oder mehreren Operanden der Programm-Anweisung abhängen. Die Operanden können mittels eines arithmetischen Codes mit oder ohne Signaturen codiert sein, z. B. mittels eines beliebigen Codes, z. B. mittels eines AN-, AND-, ANDmem-, ANB-, ANBmem-, Berger-, oder Residuum-Codes. Für die ein oder mehreren Operanden kann mittels des arithmetischen Codes überprüft werden, ob ihnen korrekt codierte Zahlenwerte zugeordnet sind. Die Signatur kann mit dem Ergebnis dieser Überprüfung verknüpft werden.
  • In verschiedenen Ausführungsformen können die Operanden oder Ergebnisse einer Programm-Anweisung zusätzlich zu den Basisblock-Signaturen überprüft werden.
  • Weiterhin kann beim Ermitteln der Basisblock-Signatur, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese jeweilige nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt werden. Beispielweise kann als beliebiger Wert ein Zufallswert gewählt werden. Nachdem der beliebe Wert gewählt worden ist, können die Basisblock-Signatur und die Basisblock-Signatur für den jeweiligen nachfolgenden Basisblock ermittelt werden. Mittels der inversen Signaturfunktion, dem beliebigen Wert und der Basisblock-Signatur, die für den jeweiligen nachfolgenden Basisblock ermittelt worden ist, nachdem der beliebe Wert gewählt wurde, kann ein Korrekturwert ermittelt werden.
  • Anschaulich können im Fall einer Schleife, also einer zyklischen Abhängigkeit von Basisblöcken, z. B. von zwei Basisblöcken, die Basisblock-Signaturen dieser Basisblöcke nicht immer ermittelt werden. Beispielsweise kann es nur wenige Signaturfunktionen geben, für die es möglich sein kann, zyklisch abhängige Basisblock-Signaturen zu ermitteln, z. B. als Fixpunkt zu ermitteln. Zudem kann die Anzahl von existierenden Fixpunkten einer Funktion limitiert sein, so dass lediglich eine begrenzte Anzahl von Schleifen in einem Programm möglich wäre.
  • Wenn eine der beiden unbekannten und nicht oder nur schwer zu ermittelnden Basisblock-Signaturen auf einen beliebigen Wert gesetzt wird, z. B. auf eine Zufallszahl, kann die zyklische Abhängigkeit aufgelöst werden und die andere Basisblock-Signatur kann ermittelt werden. Jedoch kann, wenn nun erneut die eine Basisblock-Signatur basierend auf der ermittelnden anderen Basisblock-Signatur ermittelt wird, ein anderer Wert ermittelt werden als der gewählte beliebige Wert.
  • Daher kann ein Korrekturwert ermittelt werden. Das Ergebnis der Signaturfunktion angewendet auf die ermittelte Basisblock-Signatur des einen Basisblocks und auf den Korrekturwert sollte gleich dem gewählten beliebigen Wert sein. Der Korrekturwert kann ermittelt werden, wenn die Signaturfunktion invertiert werden kann.
  • Beim Ermitteln der Referenz-Überprüfungsinformation kann der beliebige Wert als Basisblock-Signatur gewählt und der Korrekturwert ermittelt werden. Das Ermitteln der Überprüfungsinformation kann auf denselben beliebigen Wert und denselben Korrekturwert basiert sein.
  • Eine nachfolgende Basisblock-Signatur kann wegen einer zyklischen Abhängigkeit von Basisblock-Signaturen aufgrund von Programm-Schleifen oder rekursiven Programm-Aufrufen unbekannt sein. Ferner kann eine nachfolgende Basisblock-Signatur unbekannt sein, wenn zum Zeitpunkt des Ermittelns einer Basisblock-Signatur ein oder mehrere nachfolgende Basisblöcke unbekannt sind.
  • Letzteres kann der Fall sein, wenn eine Programm-Funktion von mehreren Positionen oder Stellen eines Programms aus aufgerufen werden kann. Am Ende der Programm-Funktion soll zu der Position zurückgekehrt werden, von der aus die Programm-Funktion aufgerufen wurde, um die dort nachfolgende Programm-Anweisung auszuführen. Bei Aufrufen von verschiedenen Positionen aus können das unterschiedliche Positionen sein.
  • Dem letzten Basisblock, der einer Programm-Funktion zugeordnet ist, können ein oder mehrere Basisblöcke unmittelbar folgen.
  • Je nachdem von wo die Programm-Funktion aufgerufen wurde, kann ein anderer Basisblock nachfolgen. Die unmittelbar folgenden Basisblöcke können bekannt sein, weil der Programm-Code bekannt ist. Aber vor Ausführung des Programms kann unbekannt sein, welcher nachfolgende Basisblock ausgeführt werden soll.
  • Weiterhin kann unbekannt sein, welche Programm-Funktion aufgerufen werden soll, z. B. im Fall eines Funktionszeigers (englisch: function pointer), anders ausgedrückt eines Zeigers auf eine Programm-Funktion. In diesem Fall können dem Basisblock vor dem Funktionsaufruf, der mit der Programm-Sprunganweisung endet, die dem Funktionszeiger zugeordnet ist, mehrere Basisblöcke unmittelbar nachfolgen. Zum Zeitpunkt des Ermittelns einer Basisblock-Signatur kann der nachfolgende Basisblock unbekannt sein. Denn vor Ausführung des Programms kann unbekannt sein, auf welche Programm-Funktion der Funktionszeiger zeigen soll.
  • In verschiedenen Ausführungsbeispielen kann die Basisblock-Signatur mittels der Signatur des Basisblocks und nur der Basisblock-Signatur des tatsächlich ausgeführten nachfolgenden Basisblocks ermittelt werden, z. B. im Fall einer Programm-Sprunganweisung am Ende einer Programm-Funktion, im Fall eines Funktionszeigers oder im Fall einer Programm-Abzweigung. Auf diese Weise kann Rechenzeit gespart werden, weil nicht alle unmittelbar nachfolgenden Basisblock-Signaturen berücksichtigt werden müssen.
  • In verschiedenen Ausführungsformen können je nach Art der Programm-Sprunganweisung beim Ermitteln der Basisblock-Signatur alle unmittelbar nachfolgenden Basisblöcke berücksichtigt werden oder es kann nur die Basisblock-Signatur des tatsächlich ausgeführten nachfolgenden Basisblocks berücksichtigt werden. Beispielsweise können im Fall einer Programm-Abzweigung alle nachfolgenden Basisblock-Signaturen berücksichtigt werden und im Fall einer Programm-Sprunganweisung am Ende einer Programm-Funktion wird beispielsweise die Basisblock-Signatur des tatsächlich ausgeführten nachfolgenden Basisblocks berücksichtigt.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion eine kryptographische Signaturfunktion sein, z. B. eine kryptographische Verschlüsselungsfunktion, z. B. eine symmetrische oder asymmetrische Verschlüsselungsfunktion.
  • Die kryptographische Signaturfunktion kann eine der folgenden Funktionen sein: Fortgeschrittener Verschlüsselungs-Standard (englisch: Advanced Encryption Standard, AES), Daten-Verschlüsselungs-Standard (englisch: Data Encryption Standard, DES), Triple DES.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion eine kryptographische Hash-Funktion sein.
  • Die kryptographische Hash-Funktion kann auf MD4, MD5 oder ähnliche Algorithmen basiert sein. Die kryptographische Hash-Funktion kann auf einem sicheren Hash-Algorithmus (englisch: Secure Hash Algorithm, SHA) basiert sein, z. B. SHA-1, SHA-2 oder SHA-3. Die kryptographische Hash-Funktion kann ferner auf einer algebraischen Struktur, z. B. einem modularen arithmetisch sicheren Hash (englisch: Modular Arithmetic Secure Hash, MASH), oder einem Block-Chiffre basiert sein. So kann beispielsweise MD4, MD5 oder dergleichen eingesetzt werden.
  • In verschiedenen Ausführungsbeispielen kann eine in Hardware implementierte Verschlüsselungstechnik verwendet werden.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion, z. B. die kryptographische Signaturfunktion oder die kryptographische Hash-Funktion, einen Modus unterstützen, in dem jeder Block einer nicht verschlüsselten Eingabe, auch Klartext genannt, mit einem im vorhergehenden Schritt erzeugten verschlüsselten Bock, auch Geheimtext-Block genannt, verknüpft wird, beispielsweise mittels der ausschließlichen oder -Funktion. Dieser Modus kann als Chiffre-Block-Verketten (englisch: Cipher Block Chaining, CBC) bezeichnet werden.
  • Anschaulich kann jedes Ergebnis der Signaturfunktion mit dem Ergebnis des vorangegangenen Ausführens der Signaturfunktion verknüpft werden. Wenn eine der Berechnungen der Signaturfunktion einen Fehler aufweist, z. B. weil die Signaturfunktion auf einer falschen Eingabe berechnet wurde, kann sich dieser Fehler bei den nachfolgenden Auswertungen der Signaturfunktion fortpflanzen oder propagieren. Deswegen muss das Ergebnis der Signaturfunktion nicht nach jedem Ausführen überprüft werden, sondern kann lediglich an bestimmten Auswertungs- oder Kontrollstellen überprüft werden, z. B. am Ende eines Basisblocks vor der Sprunganweisung und/oder bevor ein Basisblock ausgeführt, also aufgerufen, wird. Aus denselben Gründen muss nicht jedes Ergebnis der Signaturfunktion gespeichert werden.
  • Das Ergebnis der Signaturfunktion kann ermittelt werden, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Ergebnis mittels der Signaturfunktion verknüpft werden.
  • Anschaulich kann jeder Basisblock eine oder mehrere Programm-Anweisungen aufweisen und mit einer Programm-Sprunganweisung enden, beispielsweise zu mindestens einem nachfolgenden Basisblock. Beim Ermitteln der Signaturfunktion eines jeweiligen Basisblocks kann die Signaturfunktion initialisiert werden und basierend auf einer ersten Programm-Anweisung des Basisblocks ausgewertet werden. Danach kann die Signaturfunktion basierend auf einer nachfolgenden Programm-Anweisung des Basisblocks, z. B. der unmittelbar nachfolgenden Programm-Anweisung, z. B. der zweiten Programm-Anweisung, und dem unmittelbar zuvor berechneten Ergebnis der Signaturfunktion ausgewertet werden. Dies kann wiederholt werden, bis die Signaturfunktion nacheinander basierend auf allen Programm-Anweisungen des Basisblocks und dem jeweils unmittelbar zuvor berechneten Ergebnisses ausgewertet worden ist. Dann kann die Signaturfunktion basierend auf der Basisblock-Signatur eines nachfolgenden Basisblocks und dem von der Signaturfunktion unmittelbar zuvor berechneten Wert ausgewertet werden. Dies kann wiederum wiederholt werden, bis die Signaturfunktion basierend auf den Basisblock-Signaturen ein oder mehrerer unmittelbar nachfolgender Basisblöcke, z. B. aller unmittelbar nachfolgenden Basisblöcke, und dem von der Signaturfunktion jeweils unmittelbar zuvor berechneten Wert ausgewertet worden ist.
  • Die Signaturfunktion, z. B. die kryptographische Signaturfunktion oder die kryptographische Hash-Funktion, kann invertierbar sein. Dies ermöglicht das Ermitteln des Korrekturwerts, im Fall, dass eine Basisblock-Signatur zunächst auf einen beliebigen Wert gesetzt wird und die Basisblock-Signatur erst später ermittelt wird.
  • Weiterhin kann die Signaturfunktion, z. B. die kryptographische Signaturfunktion oder die kryptographische Hash-Funktion, derart gewählt werden, dass die Signaturfunktion in Hardware implementiert oder effizient ausgewertet werden kann, z. B. in Software effizient ausgewertet werden kann.
  • Ferner kann Signaturfunktion, z. B. die kryptographische Signaturfunktion oder die kryptographische Hash-Funktion, derart gewählt werden, dass bereits ein einziger Bit-Flip in einem Eingabewert zu einer Veränderung des Ergebniswerts führt, beispielsweise zu einer starken oder signifikanten Veränderung.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion eine beliebige Funktion sein, bei der es nicht möglich ist, mit modifizierten Eingabedaten zu demselben Ergebnis zu gelangen, wie mit den Original-Eingabedaten, also den ursprünglich vorgesehen Eingabedaten. Daher ist die zyklische Redundanzüberprüfung (englisch: Cyclic Redundancy Check, CRC) als Signaturfunktion ungeeignet.
  • Anschaulich, kann die Signaturfunktion ausgewertet werden, bevor das Programm oder bevor ein jeweiliger Basisblock des Programms ausgeführt wird. Bei Ausführung des Programms oder bei Ausführung eines jeweiligen Basisblocks kann die Signaturfunktion erneut ausgewertet werden. Beim Ermitteln der Referenz-Überprüfungsinformation und der Überprüfungsinformation kann dieselbe Signaturfunktion verwendet werden. Wenn das Ergebnis der Auswertung vor dem Ausführen nicht zu dem Ergebnis der Auswertung während des Ausführens passt, beispielsweise wenn die Ergebnisse nicht übereinstimmen, kann angenommen werden, dass die Eingabedaten für die Signaturfunktion korrumpiert sein könnten, beispielsweise kann angenommen werden, dass andere Programm-Anweisungen ausgeführt worden sein könnten.
  • Weiterhin kann ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock ausgeführt wird, z. B. bevor die Programmsprung-Anweisung ausgeführt wird.
  • In verschiedenen Ausführungsbeispielen kann ein Akkumulator-Wert mit einem Initialisierungs-Wert initialisiert werden und es kann ein erwarteter Wert auf die Referenz-Überprüfungsinformation des jeweiligen Basisblocks gesetzt werden, der als nächstes ausgeführt werden soll. Der Akkumulator und der erwartete Wert können als Register implementiert sein.
  • Der Akkumulator-Wert kann auf den Initialisierungs-Wert Null gesetzt werden, z. B. bevor der jeweilige Basisblock ausgeführt wird.
  • Das Initialisieren des Akkumulators und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation kann gemeinsam atomar ausgeführt werden.
  • Weiterhin kann der Akkumulator basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock aktualisiert werden, z. B. mittels der Signaturfunktion, wenn der jeweilige Basisblock ausgeführt wird.
  • Der Akkumulator kann basierend auf dem Befehlscode der Programm-Anweisung oder einer Signatur der Programm-Anweisung, z. B. einem der Programm-Anweisung zugeordneten Zufallswert, aktualisiert werden, die als nächstes ausgeführt wird, beispielsweise während, vor oder nachdem die Programm-Anweisung ausgeführt wird.
  • In verschiedenen Ausführungsbeispielen kann der Akkumulator-Wert mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert werden, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird. Beispielsweise kann der Akkumulator-Wert nur mit der Basisblock-Signatur des Basisblocks aktualisiert werden, zu dem gesprungen werden soll. Der Akkumulator-Wert kann ferner mit den Basisblock-Signaturen aller nachfolgenden Basisblöcke aktualisiert werden, zu denen gesprungen werden kann.
  • Ferner kann der Akkumulator-Wert basierend auf dem Korrekturwert aktualisiert werden, z. B. nachdem der dem Basisblock zugeordnete Programm-Code ausgeführt wurde und bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird, z. B. nachdem der Akkumulator mit der Basisblock-Signatur aktualisiert wurde.
  • In verschiedenen Ausführungsbeispielen kann der Akkumulator-Wert basierend auf dem erwarteten Wert überprüft werden, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
  • Es kann ermittelt erden, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen. In diesem Fall kann die Ausführung des Programms abgebrochen ober unterbrochen werden. Es kann ferner versucht werden, den Fehler zu korrigieren.
  • Der Akkumulator-Wert kann basierend auf dem erwarteten Wert überprüft werden, bevor zu einem Basisblock gesprungen wird. Beispielsweise kann der Akkumulator-Wert überprüft werden, bevor ein Basisblock ausgeführt wird, z. B. bevor der mindestens eine nachfolgende Basisblock ausgeführt wird oder bevor eine Programmsprung-Anweisung ausgeführt wird.
  • In verschiedenen Ausführungsbeispielen kann die Referenz-Überprüfungsinformation in einem Überprüfungs-Schaltkreis ermittelt oder an einen Überprüfungs-Schaltkreis übermittelt werden. Die Referenzüberprüfungsinformation kann die Basisblock-Signaturen und/oder die Korrekturwerte aufweisen. Ferner kann die Referenzüberprüfungsinformation den erwarteten Wert aufweisen und der Überprüfungs-Schaltkreis kann den erwarteten Wert auf den als nächstes zu überprüfenden Referenzwert setzen.
  • Die Überprüfungsinformation kann an den Überprüfungsschaltkreis übermittelt werden, zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf der Überprüfungsinformation und der Referenz-Überprüfungsinformation. Beispielsweise kann die Überprüfungsinformation an einen Überprüfungsschaltkreis übermittelt werden, die beim Ausführen des Programms ermittelt wird, z. B. der Akkumulator-Wert.
  • In einer Ausführungsform kann die der Akkumulator-Wert mindestens zweimal (beispielsweise vor und nach einer Aktualisierung, oder nach einer ersten Aktualisierung und nach einer zweiten Aktualisierung) übermittelt werden, und es kann ermittelt werden, ob zwischen dem ersten Übermitteln und dem zweiten Übermitteln ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist.
  • In verschiedenen Ausführungsbeispielen kann der aktualisierte Akkumulator-Wert übermittelt werden nach einer oder jeder Funktion des Programms, nach einer oder jeder Programm-Anweisung des Originalprogramms, nach einem oder jedem Basisblock, und/oder zusammen mit den Ausgaben des Programms, für die bzw. für den ermittelt werden soll, ob ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist.
  • 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, z. B. basierend auf dem Akkumulator-Wert und dem erwarteten Wert.
  • Der Überprüfungs-Schaltkreis kann in sicherer Hardware oder in Software implementiert sein. Der Überprüfungsschaltkreis kann ferner mittels arithmetischer Codes, mittels Redundanz und/oder mittels Basisblock-Singnaturen gesichert sein.
  • 2 zeigt ein Flussdiagram 200, 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. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet.
  • Anschaulich kann eine Programm-Sprunganweisung eine Abzweigung implementieren, beispielsweise eine Schleife oder eine bedingte Anweisung. Eine Programm-Sprunganweisung kann ferner einen Sprung an eine andere Position des Programms implementieren, z. B. bei Rückkehr aus einem Basisblock oder einer Funktion, bei Aufruf einer internen oder bei Aufruf einer externen Funktion.
  • In 202 kann Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms ermittelt werden. Die Basisblock-Signatur kann eine Signatur des jeweiligen Basisblocks und die Signatur von mindestens einem nachfolgenden Basisblock aufweisen. Der mindestens eine nachfolgende Basisblock kann dem jeweiligen Basisblock unmittelbar nachfolgen.
  • In verschiedenen Ausführungsbeispielen kann eine Basisblock-Signatur auf der Signatur eines Basisblocks und auf der Signatur der ein oder mehreren nachfolgenden Basisblöcke basieren, z. B. auf einer Basisblock-Signatur eines einzigen oder aller der ein oder mehreren unmittelbar nachfolgenden Basisblöcke. Beim Ermitteln der Basisblock-Signatur kann die Reihenfolge der mindestens einen Anweisung und/oder der ein oder mehreren unmittelbar nachfolgenden Basisblöcke berücksichtigt werden.
  • In 204 kann Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis empfangen werden. Die Überprüfungsinformation kann auf der Basisblock-Signatur des jeweiligen Basisblocks basieren.
  • Anschaulich können sowohl die Referenz-Überprüfungsinformation als auch die Überprüfungs-Information basierend auf der Basisblock-Signatur des jeweiligen Basisblocks ermittelt werden, also basierend auf den Signaturen der Anweisungen des jeweiligen Basisblocks, und der ein oder mehreren nachfolgenden Basisblock-Signaturen.
  • In 206 kann in dem Überprüfungsschaltkreis ermittelt werden, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • Die Referenz-Überprüfungsinformation des mindestens einen Basisblocks kann vor Ausführung des jeweiligen Basisblocks ermittelt werden.
  • In verschiedenen Ausführungsbeispielen kann die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt werden, der dem jeweiligen Basisblock unmittelbar nachfolgt.
  • Beim Ermitteln der Basisblock-Signatur kann, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt werden und ein Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock ermittelt werden. Die nachfolgende Basisblock-Signatur kann nicht ermittelt werden bei einer zyklischen Abhängigkeit der Basisblöcke oder wenn nur die nachfolgende Basisblock-Signatur berücksichtigt werden soll, die von dem Programm tatsächlich ausgeführt wird. Letzteres kann beim Ermitteln der Referenz-Überprüfungsinformation unbekannt sein.
  • Der beliebige Wert kann als Basisblock-Signatur gewählt und der Korrekturwert kann ermittelt werden, wenn die Referenz-Überprüfungsinformation ermittelt wird, also in dem Überprüfungsschaltkreis.
  • In verschiedenen Ausführungsbeispielen kann die Signaturfunktion eine kryptographische Signaturfunktion sein.
  • Ferner kann die kryptographische Signaturfunktion kann eine kryptographische Hash-Funktion sein.
  • Die kryptographische Hash-Funktion eine der folgenden Funktionen sein: MD4, MD5, und dergleichen.
  • Die Signaturfunktion kann ermittelt werden, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft werden.
  • Ob bei der Ausführung des Programms ein Fehler aufgetreten ist, kann ermittelt werden bevor der mindestens eine nachfolgende Basisblock aufgerufen wird. Zumindest kann die Überprüfungsinformation zum Ermitteln, ob ein Fehler aufgetreten ist, an den Überprüfungsschaltkreis übermittelt werden, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  • In verschiedenen Ausführungsbeispielen kann ein Akkumulator-Wert mit einem Initialisierungs-Wert initialisiert werden und ein erwarteter Wert auf die Referenz-Überprüfungsinformation des Basisblocks gesetzt werden, der als nächstes ausgeführt werden soll.
  • Das Initialisieren des Akkumulators und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation kann gemeinsam atomar ausgeführt werden.
  • Der Akkumulator kann basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock aktualisiert werden, wenn der jeweilige Basisblock in dem Programm ausgeführt wird. Der Akkumulator kann mit allen unmittelbar nachfolgenden Basisblock-Signaturen oder nur mit der Basisblock-Signatur des nachfolgenden Basisblock aktualisiert werden, der als nächstes ausgeführt werden soll. Der Akkumulator und der erwartete Wert können als Register implementiert sein, z. B. jeweils in dem Programm bzw. in dem Überprüfungsschaltkreis.
  • Der Akkumulator-Wert kann basierend auf dem Korrekturwert aktualisiert werden.
  • In verschiedenen Ausführungsformen kann zum Aktualisieren des Akkumulators die Referenz-Überprüfungsinformation von dem Überprüfungsschaltkreis an das Programm übermittelt werden, z. B. die Basisblock-Signaturen und die Korrekturwerte, z. B. die mindestens eine unmittelbar nachfolgenden Basisblock-Signatur und der ggf. benötigte Korrekturwert.
  • Der Akkumulator kann mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert werden, bevor das Programm in den mindestens einen nachfolgenden Basisblock springt.
  • Der Akkumulator-Wert kann an den Überprüfungsschaltkreis übermittelt werden. Zum Ermitteln, ob bei der Ausführung des Programms ein Fehler (in anderen Worten ein Ausführungsfehler) aufgetreten ist, können in dem Überprüfungsschaltkreis der übermittelte Akkumulator-Wert und der erwartete Wert miteinander verglichen werden.
  • In einer Ausführungsform kann der aktualisierte Akkumulator-Wert empfangen werden nach einer oder jeder Funktion des Programms, nach einer oder jeder Programm-Anweisung des Originalprogramms, nach einem oder jedem Basisblock, und/oder zusammen mit den Ausgaben des Programms, für die bzw. für den ermittelt werden soll, ob ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist.
  • In einer Ausführungsform kann der Akkumulator-Wert mindestens zweimal (beispielsweise vor und nach einer Aktualisierung, oder nach einer ersten Aktualisierung und nach einer zweiten Aktualisierung) empfangen werden, und es kann ermittelt werden, ob zwischen dem ersten Empfangen und dem zweiten Empfangen ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist.
  • Wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen, kann ermittelt werden, dass bei der Ausführung des Programms ein Fehler aufgetreten ist.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis in sicherer Hardware implementiert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch arithmetische Codes und/oder Basisblock-Signaturen abgesichert sein.
  • 3 zeigt ein Flussdiagram 300, das ein Verfahren zur Datenverarbeitung zum Erzeugen von Programm-Code 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. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet.
  • In 302 kann ein Programm-Code-Abschnitt zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks erzeugt werden. Die Basisblock-Signatur kann eine Signatur des jeweiligen Basisblocks und die Signatur von mindestens einem nachfolgenden Basisblock aufweisen. Der mindestens eine nachfolgende Basisblock kann dem jeweiligen Basisblock unmittelbar nachfolgen.
  • In 304 kann ein Programm-Code-Abschnitt zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks erzeugt werden.
  • In verschiedenen Ausführungsbeispielen können die Programm-Code-Abschnitte derart erzeugt werden, dass eine Basisblock-Signatur auf der Signatur eines Basisblocks und auf der Signatur der ein oder mehreren nachfolgenden Basisblöcke basiert, z. B. auf einer Basisblock-Signatur eines einzigen oder aller der ein oder mehreren unmittelbar nachfolgenden Basisblöcke.
  • Anschaulich können sowohl die Referenz-Überprüfungsinformation als auch die Überprüfungs-Information basierend auf der Basisblock-Signatur des jeweiligen Basisblocks ermittelt werden, also basierend auf den Signaturen der Anweisungen des jeweiligen Basisblocks, und der ein oder mehreren nachfolgenden Basisblock-Signaturen.
  • In 306 kann ein Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation erzeugt werden.
  • In einer Ausführungsform kann der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation, derart erzeugt werden, dass die Referenz-Überprüfungsinformation des mindestens einen Basisblocks vor Ausführung des jeweiligen Basisblocks ermittelt wird.
  • In einer Ausführungsform können die Programm-Code-Abschnitte zum Ermitteln der Referenz-Überprüfungsinformation und der Überprüfungsinformation derart erzeugt werden, dass die Basisblock-Signatur des jeweiligen Basisblocks mittels einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt wird, der dem jeweiligen Basisblock unmittelbar nachfolgt.
  • Ferner kann der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation derart erzeugt werden, dass beim Ermitteln der Basisblock-Signatur, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur ein beliebiger Wert gewählt wird und ein Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock ermittelt wird. Die nachfolgende Basisblock-Signatur kann nicht ermittelt werden bei einer zyklischen Abhängigkeit der Basisblöcke oder wenn nur die nachfolgende Basisblock-Signatur berücksichtigt werden soll, die von dem Programm tatsächlich ausgeführt wird. Letzteres kann beim Ermitteln der Referenz Überprüfungsinformation unbekannt sein.
  • Der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation kann ferner derart erzeugt werden, dass der beliebige Wert als Basisblock-Signatur gewählt und der Korrekturwert ermittelt wird.
  • In verschiedenen Ausführungsformen können die Programm-Code-Abschnitte zum Ermitteln der Referenz-Überprüfungsinformation und der Überprüfungsinformation derart erzeugt werden, dass die Signaturfunktion eine kryptographische Signaturfunktion ist. Weiterhin können die Programm-Code-Abschnitte derart erzeugt werden, dass die kryptographische Signaturfunktion eine kryptographische Hash-Funktion ist. Die kryptographische Hash-Funktion kann eine der folgenden Funktionen sein: MD4, MD5, und dergleichen.
  • Die Programm-Code-Abschnitte können derart erzeugt werden, dass die Signaturfunktion ermittelt wird, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft wird.
  • Weiterhin kann der Programm-Code-Abschnitt zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, derart erzeugt werden, dass ermittelt wird, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  • Es kann ein Programm-Code-Abschnitt erzeugt werden zum Initialisieren eines Akkumulator-Werts mit einem Initialisierungs-Wert und zum Setzen eines erwarteten Werts auf die Referenz-Überprüfungsinformation des Basisblocks, der als nächstes ausgeführt werden soll.
  • Das Initialisieren des Akkumulator-Werts und das Setzen des erwarteten Werts auf die Referenz-Überprüfungsinformation kann gemeinsam atomar ausgeführt werden.
  • Der Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation kann derart erzeugt werden, dass der Akkumulator-Wert basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock, z. B. von allen nachfolgenden Basisblöcken, aktualisiert wird, wenn der jeweilige Basisblock ausgeführt wird.
  • Der Programm-Code-Abschnitt zum Aktualisieren kann derart erzeugt werden, dass der Akkumulator-Wert mit der Basisblock-Signatur des nachfolgenden Basisblock aktualisiert wird, der als nächstes ausgeführt werden soll.
  • Der Programm-Code-Abschnitt zum Aktualisieren kann derart erzeugt werden, dass der Akkumulator-Wert mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert wird, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird.
  • Ferner kann ein Programm-Code-Abschnitt zum Aktualisieren des Akkumulator-Werts basierend auf dem Korrekturwert erzeugt werden.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln, ob ein Fehler aufgetreten ist, derart erzeugt werden, dass der Akkumulator-Wert basierend auf dem erwarteten Wert überprüft wird, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
  • Der Programm-Code-Abschnitt zum Ermitteln, ob ein Fehler aufgetreten ist, kann ferner derart erzeugt werden, dass ermittelt wird, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und der erwartete Wert nicht übereinstimmen.
  • In verschiedenen Ausführungsbeispielen kann der Programm-Code-Abschnitt zum Ermitteln der Referenz-Überprüfungsinformation derart erzeugt werden, dass die Referenz-Überprüfungsinformation in einem Überprüfungs-Schaltkreis ermittelt wird.
  • Ferner kann Programm-Code-Abschnitt zum Ermitteln der Überprüfungsinformation derart erzeugt werden, dass die ermittelte Überprüfungsinformation an den Überprüfungsschaltkreis übermittelt wird zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf der Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  • In einer Ausführungsform kann ein Programm-Code-Abschnitt zum Übermitteln des Akkumulator-Wertes nach einer oder jeder Funktion des Programms, nach einer oder jeder Programm-Anweisung des Originalprogramms, nach einem oder jedem Basisblock, und/oder zusammen mit den Ausgaben des Programms, für die bzw. für den ermittelt werden soll, ob ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist, erzeugt werden.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis außerhalb des Programms und/oder in sicherer Hardware implementiert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch arithmetische Codes und/oder Basisblock-Signaturen abgesichert sein.
  • 4 zeigt eine Datenverarbeitungsanordnung 400 zum Ermitteln, ob bei einer Ausführung eines Programms (anders ausgedrückt: ob bei (oder: ob in) einer Programmausführung) ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet. Die Datenverarbeitungsanordnung 400 kann einen Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis 402 enthalten, der eingerichtet ist, Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks zu ermitteln, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann die Datenverarbeitungsanordnung 400 einen Überprüfungsinformation-Ermittlungs-Schaltkreis 404 enthalten, der eingerichtet ist, Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks zu ermitteln, Weiterhin kann die Datenverarbeitungsanordnung 400 kann einen Überprüfungsschaltkreis enthalten, der eingerichtet ist, zu ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation. Der Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis 402, der Überprüfungsinformation-Ermittlungs-Schaltkreis 404 und der Überprüfungs-Schaltkreis 406 können über eine Verbindung 408, z. B. über eine drahtbasierte oder eine drahtlose Verbindung, z. B. über einen Bus, miteinander kommunizieren und Informationen austauschen.
  • Anschaulich kann die Datenverarbeitungsanordnung 400 eine Anordnung sein zum Ausführen eines Programms, das auf Fehler überwacht werden soll. Die Referenz-Überprüfungsinformation eines jeweiligen Basisblocks kann ermittelt werden, bevor der Basisblock ausgeführt wird.
  • In einer Ausführungsform kann die Datenverarbeitungsanordnung 400 ferner enthalten einen Block-Signatur-Ermittlung-Schaltkreis (nicht gezeigt), der eingerichtet ist zum Ermitteln einer Basisblock-Signatur basierend auf einer Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem unmittelbar nachfolgenden Basisblock, z. B. der Basisblock-Signatur des Basisblocks, der als nächstes ausgeführt werden soll, oder jeweils der Basisblock-Signatur aller Basisblöcke, von denen einer ausgeführt werden könnte.
  • In einer Ausführungsform kann der Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis 404 eingerichtet sein, wenn die Basisblock-Signatur von mindestens einem nachfolgenden Basisblock nicht ermittelt werden kann, für diese nachfolgende Basisblock-Signatur einen beliebige Wert zu wählen und einen Korrekturwert mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock zu ermitteln.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis in sicherer Hardware oder in Software implementiert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch arithmetische Codes und/oder Basisblock-Signaturen abgesichert sein.
  • 5 zeigt eine Datenverarbeitungsanordnung 500 zum Ermitteln, ob bei einer Ausführung eines Programms (anders ausgedrückt: ob bei (oder: ob in) einer Programmausführung) ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet. Die Datenverarbeitungsanordnung 500 kann einen Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis 502 enthalten, der eingerichtet ist, Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms zu ermitteln, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann die Datenverarbeitungsanordnung 500 einen Empfangs-Schaltkreis 504 enthalten, der eingerichtet ist, Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis zu empfangen, wobei die Überprüfungsinformation auf der Basisblock-Signatur des jeweiligen Basisblocks basiert. Weiterhin kann die Datenverarbeitungsanordnung 500 einen Überprüfungsschaltkreis 506 enthalten, der eingerichtet ist, zu ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz Überprüfungsinformation. Der Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis 502, der Überprüfungsinformation-Ermittlungs-Schaltkreis 504 und der Überprüfungs-Schaltkreis 506 können über eine Verbindung 508, z. B. über eine drahtbasierte oder eine drahtlose Verbindung, z. B. über einen Bus, miteinander kommunizieren und Informationen austauschen.
  • Anschaulich kann die Datenverarbeitungsanordnung 500 eine Anordnung sein zum Überprüfen, ob ein Fehler (in anderen Worten: ein Ausführungsfehler) in einer anderen Datenverarbeitungseinrichtung aufgetreten ist.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis 506 in sicherer Hardware oder in Software implementiert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis 506 durch Redundanz abgesichert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis 506 durch arithmetische Codes und/oder Basisblock-Signaturen abgesichert sein.
  • 6 zeigt eine Datenverarbeitungsanordnung 600 zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms (anders ausgedrückt: ob bei (oder: ob in) einer Programmausführung) ein Fehler aufgetreten ist, gemäß einem Ausführungsbeispiel. Das Programm kann mindestens einen Basisblock aufweisen, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet. Die Datenverarbeitungsanordnung 600 kann einen Referenz-Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 602 enthalten, der eingerichtet ist, einen Programm-Code-Abschnitt zu erzeugen zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und optional die Signatur von mindestens einem nachfolgenden Basisblock aufweist, der dem jeweiligen Basisblock unmittelbar nachfolgt. Ferner kann die Datenverarbeitungsanordnung 600 einen Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 604 enthalten, der eingerichtet ist, einen Programm-Code-Abschnitt zu erzeugen zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks. Weiterhin kann die Datenverarbeitungsanordnung 600 einen Überprüfungs-Code-Abschnitt-Erzeugungs-Schaltkreis 606 enthalten, der eingerichtet ist, einen Programm-Code-Abschnitt zu erzeugen zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation. Der Referenz-Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 602, der Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 604 und der Überprüfungs-Code-Abschnitt-Erzeugungs-Schaltkreis 606 können über eine Verbindung 608, z. B. über eine drahtbasierte oder eine drahtlose Verbindung, z. B. über einen Bus, miteinander kommunizieren und Informationen austauschen.
  • Anschaulich kann die Datenverarbeitungsanordnung 600 ein Compiler sein zum Erzeugen eines Programm-Codes, der von einer Datenverarbeitung zur Ausführung eines Programms ausgeführt werden kann.
  • In einer Ausführungsform kann die Datenverarbeitungsanordnung 600 ferner enthalten einen Basisblock-Signatur-Code-Abschnitt-Erzeugungs-Schaltkreis (nicht gezeigt), der eingerichtet ist zum Ermitteln einer Basisblock-Signatur basierend auf einer Signaturfunktion der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem unmittelbar nachfolgenden Basisblock, z. B. der Basisblock-Signatur des Basisblocks, der als nächstes ausgeführt werden soll, oder jeweils der Basisblock-Signatur aller Basisblöcke, von denen einer ausgeführt werden könnte.
  • In einer Ausführungsform kann der Referenz-Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 602 eingerichtet sein zum Erzeugen eines Programm-Code-Abschnitts zum Wählen eines beliebigen Werts für eine nachfolgende Basisblock-Signatur von mindestens einem nachfolgenden Basisblock, wenn diese Basisblock-Signatur nicht ermittelt werden kann, und zum Ermitteln eines Korrekturwerts mittels der inversen Signaturfunktion, dem beliebigen Wert und einer danach ermittelten Basisblock-Signatur für diesen nachfolgenden Basisblock.
  • In einer Ausführungsform kann der Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis 604 eingerichtet sein Erzeugen eines Programm-Code-Abschnitt zum Übermitteln der Überprüfungsinformation an einen Überprüfungsschaltkreis nach einer oder jeder Funktion des Programms, nach einer oder jeder Programm-Anweisung des Originalprogramms, nach einem oder jedem Basisblock, und/oder zusammen mit den Ausgaben des Programms, für die bzw. für den ermittelt werden soll, ob ein Fehler (in anderen Worten: ein Ausführungsfehler) aufgetreten ist.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis in sicherer Hardware oder in Software implementiert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch Redundanz abgesichert sein.
  • In einer Ausführungsform kann der Überprüfungs-Schaltkreis durch arithmetische Codes und/oder Basisblock-Signaturen abgesichert sein.
  • Es kann ein Computerprogrammelement bereitgestellt werden, das, wenn es von einem Prozessor ausgeführt wird, bewirkt, dass der Prozessor eines der oben genannten Verfahren 100, 200, 300 zur Datenverarbeitung ausführt.
  • Gemäß Ausführungsformen können Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden für die automatische Überwachung eines Programmablaufs von mit Basisblock-Signaturen geschützten Programmen zur frühzeitigen Erkennung von fehlerhaften Abweichungen im Kontrollfluss des Programms.
  • Gemäß Ausführungsformen können Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden zum Überprüfen des Kontrollflusses und Detektieren von Programm-Sprüngen an falsche oder nicht erlaubte Positionen während des Programmablaufs.
  • Gemäß Ausführungsformen können Datenverarbeitungsanordnungen und Verfahren bereitgestellt werden zum Verwenden von zur Laufzeit des Programms erzeugten Basisblock-Signaturen. Die erzeugten Basisblock-Signaturen können dabei unauflösbar von dem Kontrollfluss der geschützten Ausführung des Programmes abhängen. Falls es zu einem Fehler im Kontrollfluss kommt, kann die geschützte Anwendung nicht den Wert zur Überprüfung senden, der von dem Überprüfungs-Schaltkreis erwartetet wird, z. B. einem Watchdog (deutsch: Aufpasser-Einheit), einem Aufpasser-Prozess oder speziellen Anweisungen, die z. B. in Hardware implementiert sind.
  • Gemäß Ausführungsformen kann die Frequenz der an den Überprüfungsschaltkreis zur Überprüfung gesendeten Werte von „nach jeder Instruktion” über „nach jedem Basisblock” oder „vor einem Programm-Sprung” bis „vor der Ausgabe” angepasst werden, so dass Fehler erkannt werden können ehe eine fehlerhafte Ausgabe extern sichtbar wird.
  • Gemäß Ausführungsformen kann der zu schützende Quellcode des Programms 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 außerhalb des Programms oder mittels spezieller sicherer Anweisungen überprüft werden, z. B. als Erweiterung des CPU-Befehlssatzes, z. B. von innerhalb des Programms.
  • 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äß Ausführungsformen kann ein vollständig automatisierter Schutz von dynamischen und geschachtelten Ablaufbeschreibungen und des Kontrollflusses von beliebigen Programmen zur Erkennung von Fehlern während der Ausführung bereitgestellt werden. Der Kontrollfluss kann dabei von zur Laufzeit ermittelten Daten abhängen, z. B. bei bedingten Programm-Sprüngen oder Funktionszeigern.
  • Gemäß Ausführungsformen können die Basisblock-Signaturen als akkumulierte Signaturen generiert werden, was eine flexible Anpassung des Schutzes an die geforderte Sicherheit erlauben und wenig zusätzlichem Speicher- und CPU-Overhead erfordern kann.
  • Gemäß Ausführungsformen können nur wenig zusätzliche CPU-Zyklen und Programmspeicher benötigt werden. Die Signaturfunktion, z. B. die sichere Hash-Funktion, kann in Hardware implementiert sein.
  • Gemäß Ausführungsformen kann das durch z. B. einen Software-Codier-Compiler erzeugte, geschützte Programm direkt auf unsicherer Hardware ausgeführt werden.
  • Gemäß Ausführungsformen kann der Umfang des Schutzes durch den Anwender flexibel bestimmt werden.
  • Gemäß Ausführungsformen kann die Implementierung von „fail-fast” verhalten in Programmen bereitgestellt werden, das heißt Fehler können so schnell wie möglich erkannt werden, was eine frühzeitige Reaktion erlauben kann.
  • Gemäß Ausführungsformen 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, die heutzutage zunehmend mit dem Internet verbunden werden. Ohne Schutzmechanismen können Schadprogramme den Kontrollfluss eines Programms beliebig verändern. Wenn neben dem Schutz des Programm-Codes mittels der oben beschriebenen Basisblock-Signaturen auch Speicherinhalte verschlüsselt werden, ohne dass das Betriebssystem Zugriff auf den Schlüssel hat, kann der Kontrollfluss des Programms gegen Angriffe geschützt werden.
  • 7 zeigt eine Datenverarbeitungsanordnung 700 gemäß einem Ausführungsbeispiel der Erfindung. Die Datenverarbeitungsanordnung 700 kann eingesetzt werden als eine oder mehrere der oben genannten Datenverarbeitungsanordnungen (beispielsweise wie in 4 bis 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üfungsschaltkreis oder die sicheren speziellen Anweisungen zur Überprüfung, zum Ermitteln der Referenz-Überprüfungsinformation oder der Überprüfungsinformation, z. B. zur Aktualisierung des Akkumulators und des erwarteten Werts, in der gesicherten Spezialhardware 708 bereitgestellt werden, die gesichert fehlerfrei arbeitet. Die beschriebenen Komponenten der Datenverarbeitungsanordnung 700 können mit einer Verbindung 716, beispielsweise einer drahtbasierten Verbindung, einem Bus, einem Netzwerk oder mittels einer drahtlosen Verbindung miteinander kommunizieren und Informationen austauschen.
  • Gemäß Ausführungsformen wird ein Codier-Compiler (englisch: „Encoding Compiler”) bereitgestellt, der automatisch die Signaturen, die den Anweisungen zugeordnet sind, erzeugen und die Basisblock-Signaturen und Korrekturwerte ermitteln kann. Ferner kann der Codier-Compiler Programm-Code-Abschnitte zum Ermitteln der Überprüfungsinformation, z. B. des Akkumulator-Werts, und zum Vergleichen der Überprüfungsinformation mit der Referenz-Überprüfungsinformation erzeugen, z. B. mit dem erwarteten Wert, der dem zu überprüfenden Basisblock zugeordnet ist. Fehler-Injektionen zeigen, dass mittels der Basisblock-Signaturen erfolgreich Fehler im Kontrollfluss, inklusive Fehler an Verzweigungen, in Schleifen und bei Funktionsaufrufen oder der Rückkehr aus einer Funktion, detektiert werden können.
  • Gemäß Ausführungsformen werden Datenverarbeitungsanordnungen und Verfahren zum Ermitteln von Basisblock-Signaturen, welche einen aktuellen Basisblock und ein oder mehrere unmittelbar nachfolgende Basisblöcke berücksichtigen, und zum Ermitteln von Hardware-Fehlern in Software bereitgestellt. Dabei können alle in der Programm-Ablaufbeschreibung unmittelbar nachfolgenden Basisblöcke, nur der nachfolgende Basisblock berücksichtigt werden, der bei Ausführung des Programms tatsächlich ausgeführt wird, oder eine Kombination aus beidem berücksichtigt werden. Welcher Basisblock ausgeführt wird, kann beim Ermitteln der Basisblock-Signaturen als Referenz-Überprüfungsinformation unbekannt sein.
  • Gemäß Ausführungsformen können Abweichungen im Kontrollfluss des Programms frühzeitig während der Ausführung des Programms erkannt werden. Abweichungen im Kontrollfluss können deterministisch erkannt werden, wenn bei der Zuordnung der Überprüfungsinformation und der Referenz Überprüfungsinformation zu den gemäß der Ablaufbeschreibung auszuführen Basisblöcken kein Fehler auftritt. Falls ein Fehler bei der Zuordnung der Überprüfungsinformation und der Referenz-Überprüfungsinformation zu den gemäß der Ablaufbeschreibung auszuführen Basisblöcken auftreten sollte, können die Überprüfungsinformation und die Referenz-Überprüfungsinformation mit hoher Wahrscheinlichkeit nicht übereinstimmen.
  • 8 zeigt eine Darstellung 800 des Kontrollflusses zwischen mehreren Basisblöcken gemäß einem Ausführungsbeispiel. Die Ausführung eines Programms kann an einem ersten Basisblock 802 starten, der ein oder mehreren Programm-Anweisungen bis zu einer ersten Programm-Sprunganweisung zugeordnet ist. Die erste Programm-Sprunganweisung kann eine erste bedingte Abzweigung sein, z. B. zu einem zweiten Basisblock 804 oder einem dritten Basisblock 806. Beispielsweise kann der zweite Basisblock 804 ausgeführt werden, wenn eine Abfrage den Wert „wahr” ergibt, und der dritte Basisblock 806 kann ausgeführt werden, wenn die Abfrage den Wert „falsch” ergibt. Alternativ können der ersten Programm-Sprunganweisung der zweite Basisblock 804, der dritte Basisblock 806 und ein oder mehrere weitere Basisblöcke (nicht dargestellt) nachfolgen, von denen einer gemäß dem Ergebnis einer Auswahlanweisung aufgerufen werden kann. Der zweite Basisblock 804 kann Teil einer Schleife sein. Dem zweiten Basisblock 804 können ein oder mehrere weitere zweite Basisblöcke 808 folgen bevor in den ersten Basisblock 802 zurückgesprungen wird. Es kann auch nach dem zweiten Basisblock 804 in den ersten Basisblock zurückgesprungen werden (nicht dargestellt), z. B. ohne dass ein Programm die weiteren zweiten Basisblöcke 808 aufweist. Der zweite Basisblock 804 kann eine zweite bedingte Abzweigung aufweisen, an der gemäß einer Bedingung ein vierter Basisblock 810 oder einer der ein oder mehreren weiteren zweiten Basisblöcken 808 ausgeführt wird.
  • Gemäß Ausführungsbeispielen kann nach dem Ausführen der Schleife in den ersten Basisblock 802 zurückgesprungen werden. Nachdem die ein oder mehreren Anweisungen des ersten Basisblocks 802 ausgeführt worden sind, kann an der ersten Programm-Sprunganweisung in den dritten Basisblock 806 gesprungen werden.
  • Gemäß Ausführungsbeispielen kann am Ende der weiteren zweiten Basisblöcke 808 zu dem ersten Basisblock 802 ohne Abfrage einer Bedingung gesprungen werden, auch unbedingter Sprung oder unbedingte Abzweigung genannt.
  • Gemäß Ausführungsbeispielen kann ein Programm beliebig viele Basisblöcke 802, 804, 806, 808, 810 in beliebigen Aneinanderreihungen aufweisen. Beispielsweise kann ein Programm den ersten und dritten Basisblock 802, 806, eine Schleife mit dem ersten und zweiten Basisblock 802, 804 oder eine Kombination beider aufweisen.
  • Gemäß Ausführungsbeispielen kann eine Schleife als eine Sequenz von Anweisungen innerhalb des Schleifenkörpers aufgefasst werden, die abhängig von einer Schleifen-Bedingung einfach oder mehrfach ausgeführt werden können. In einer Schleife hängen die erste Basisblock-Signatur BSl des ersten Basisblocks 802 und die letzte Basisblock-Signatur BSj des letzten Basisblocks 808 der Schleife zyklisch voneinander ab: BS1 ≔ f(il, ..., ik, br, BS2, BSj) BS2 ≔ = f(ik+1, ..., ik+l, br, BSj) BSj ≔ f(..., br, BS1)
  • Beim Ermitteln der Basisblock-Signaturen, z. B. beim Ermitteln, der Referenz-Überprüfungsfunktion, kann eine der Basisblock-Signaturen nicht direkt ermittelt werden (außer das zugeordnete Gleichungssystem hätte eine Lösung). Deshalb kann eine der Basisblock-Signaturen, z. B. die letzte Basisblock-Signatur BSj auf einen belieben Wert BSrand gesetzt werden, z. B. einen Zufallswert. Dann können die anderen Basisblock-Signaturen BS1, BS2 der Schleife berechnet werden: BS1 ≔ f(i1, ..., ik, br, f(ik+1, ..., ik+l, br, BSrand)) BS2 ≔ f(ik+1, ..., ik+l, br, BSrand) BSj ≔ BSrand
  • Am Ende des ersten Schleifendurchlaufs bzw. nachdem alle Basisblock-Signaturen der Schleife wie oben beschrieben ermittelt worden sind, kann die Basisblock-Signatur BSj' für den letzten Basisblock 808 ermittelt werden, basierend auf dem Wert der vor dem Schleifendurchlauf für die erste Basisblock-Signatur BS1 ermittelt worden ist. Die ermittelte letzte Basisblock-Signatur BSj' und der beliebige Wert BSrand für den letzten Basisblock der Schleife müssen nicht übereinstimmen. Wenn die Signaturfunktion invertiert werden kann, kann für den letzten Basisblock ein Korrekturwert v berechnet werden: f(BSj', v) ≔ BSrand.
  • Gemäß Ausführungsbeispielen kann der Korrekturwert v gemeinsam mit dem beliebigen Wert für die Basisblock-Signatur des letzten Basisblocks als Referenz-Überprüfungsinformation gespeichert werden. Jedes Mal, wenn eine Basisblock-Signatur für den letzten Basisblock einer Schleife ermittelt worden ist, kann diese ermittelte Basisblock-Signatur mittels des Korrektur-Werts korrigiert werden. Bei einer fehlerfreien Ausführung kann sich nach der Korrektur der beliebige Wert ergeben.
  • Gemäß Ausführungsbeispielen kann für einen beliebigen Basisblock der Schleife, z. B. für den ersten oder letzten Basisblock, die Basisblock-Signatur auf den beliebigen Wert gesetzt, der Korrekturwert ermittelt und beide als Referenz-Überprüfungsinformation gespeichert werden.
  • Gemäß Ausführungsformen kann die Schleife einen einzigen Basisblock, der sich selber aufruft, zwei oder mehr Basisblöcke aufweisen.
  • Zur Veranschaulichung eines Basisblocks, der einen unbedingten Sprung aufweist, sei folgendes Niedriger-Level-Virtuelle-Maschine (Low Level Virtual Machine, LLVM)-Code-Beispiel betrachtet:
    Figure DE102014117971B4_0002
  • Bevor eine Programm-Anweisung ausgeführt wird, z. B. die Anweisung „lade” (LLVM: load) oder die Anweisung „vergleiche” (LLVM: icmp), kann eine der jeweiligen Anweisung zugeordnete Signatur zu der Überprüfungsinformation hinzugefügt werden. Beispielsweise kann die Signatur zu der Überprüfungsinformation hinzugefügt werden unmittelbar bevor die Anweisung ausgeführt wird. In dem obigen Beispiel wird mittels einer „push”-Anweisung der Wert „27” für die „lade”-Anweisung und der Wert „45” für die „vergleiche”-Anweisung hinzugefügt. Beispielsweise kann die Überprüfungsinformation einen Akkumulator-Wert aufweisen und mit jeder „push”-Anweisung kann der Akkumulator-Wert aktualisiert werden.
  • Die Signatur, z. B. „27” für die „lade”-Anweisung, mit der zugehörigen „push”-Anweisung kann vorab automatisch oder manuell ermittelt und in den Programm-Code eingefügt worden sein. Die vorab ermittelten oder vorbestimmten Signaturen können in einem Feld, einer Liste oder einer beliebigen Datenstruktur gespeichert werden. Der Anweisung zum Aktualisieren der Überprüfungsinformation, z. B. die push-Anweisung, kann als eine Signatur, eine in den Programm-Code eingefügte Konstante, ein Element der Datenstruktur, ein Index oder ein Verweis auf das Element der Datenstruktur übergeben werden.
  • Bevor die unbedingte Sprunganweisung ausgeführt wird, können die Signaturen „2” für die Abzweigung und „1311136857” für den nachfolgenden Basisblock, zu dem gesprungen werden soll, zu der Überprüfungsinformation mittels jeweils einer „push”-Anweisung hinzugefügt werden. Diese beiden Signaturen können zu der Überprüfungsinformation hinzugefügt werden, nachdem die vorangehenden Programm-Anweisungen ausgeführt wurden. Auch diese beiden Signaturen können in einem Feld, einer Liste oder einer beliebigen Datenstruktur gespeichert werden.
  • Signaturen für Basisblöcke, Basisblock-Signaturen genannt, können in einer separaten Datenstruktur gespeichert werden. Die Basisblock-Signaturen können ermittelt und als Referenz-Überprüfungsinformation einer der Datenstruktur gespeichert oder als Konstanten in das Programm eingefügt werden.
  • Weiterhin kann, bevor die Programm-Sprunganweisung ausgeführt wird, z. B. die Abzweige-Anweisung „br”, die Überprüfungsinformation mit der Referenz-Überprüfungsinformation verglichen werden, um zu ermitteln, ob bei Ausführung der mindesten einen Programm-Anweisung, die einem Basisblock zugeordnet ist, ein Fehler aufgetreten ist. In dem obigen Beispiel wird hierzu eine „expectedSig”-Anweisung aufgerufen, um zu überprüfen, ob der Basisblock ausgeführt wurde, der die „lade”-Anweisung, die „vergleiche”-Anweisung und die Abzweige-Anweisung zu dem nächsten Basisblock aufweist. Anschaulich wird überprüft, ob der richtige Basisblock gemäß der Ablaufbeschreibung ausgeführt wird.
  • Gemäß Ausführungsbeispielen kann die Anweisung zum Überprüfen, z. B. die „expectedSig”-Anweisung, die Überprüfungsinformation, die diesem Basisblock zugeordnet ist, mit der Referenz-Überprüfungsinformation, die diesem Basisblock zugeordnet ist, vergleichen. Der Akkumulator-Wert kann mit einem erwarteten Wert der Referenz-Überprüfungsinformation verglichen werden, der diesem Basisblock zugeordnet ist. Danach kann der Akkumulator zurückgesetzt, z. B. auf „0” initialisiert, werden und aus der Referenz-Überprüfungsinformation ein erwarteter Wert für die nächste Überprüfung ausgewählt werden, z. B. kann der erwartete Wert auf die unmittelbar nachfolgende Basisblock-Signatur gesetzt werden, in diesem Beispiel auf „1311136867”. Wenn nach dem Sprung der richtige Basisblock ausgeführt wird, kann bei der nächsten Überprüfung auch die Überprüfungsinformation die Basisblock-Signatur des unmittelbar nachfolgenden Basisblocks aufweisen, z. B. den Wert „1311136867”. Falls zu einem falschen Basisblock gesprungen wird, kann für die Überprüfungsinformation ein falscher Wert ermittelt werden. Ein falscher Basisblock kann mindestens eine andere Anweisung, mindestens einen anderen unmittelbaren Nachfolger und/oder Anweisungen in einer anderen Reihenfolge aufweisen. Dann kann eine andere Basisblock-Signatur ermittelt werden, weil zu der Überprüfungsinformation eine falsche Signatur hinzugefügt wird oder die Signaturen in der falschen Reihenfolge hinzugefügt werden.
  • Gemäß Ausführungsbeispielen kann das Überprüfen der Überprüfungsinformation und der Referenz-Überprüfungsinformation, z. B. das Vergleichen des Akkumulator-Werts mit dem erwarteten Wert, mittels einer Anweisung ausgeführt werden. Das Initialisieren der Überprüfungsinformation und das Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock kann mittels dieser Anweisung oder einer anderen Anweisung ausgeführt werden.
  • Die Referenz-Überprüfungsinformation kann analog zu dem Aktualisieren der Überprüfungsinformation ermittelt werden, z. B. bei einer anderen Ausführung der Basisblöcke, z. B. bei einem speziellen Ausführen der Basisblöcke. Vor dem Abarbeiten eines jeweiligen Basisblocks kann die diesem Basisblock zugeordnete Referenz-Überprüfungsinformation initialisiert werden, z. B. indem der zugeordnete erwartete Wert auf „0” gesetzt wird. Beim Abarbeiten eines Basisblocks können ein oder mehrere Anweisungen zum Aktualisieren der Referenz-Überprüfungsinformation ausgeführt werden, z. B. die „push”-Anweisungen, z. B. können nur die ein oder mehreren Anweisungen zum Aktualisieren der Referenz-Überprüfungsinformation ausgeführt werden.
  • Das folgende Niedriger-Level-Virtuelle-Maschine (Low Level Virtual Machine, LLVM)-Code-Beispiel ist einem Basisblock zugeordnet, der mit einer bedingten Programm-Sprunganweisung endet:
    Figure DE102014117971B4_0003
  • Ähnlich wie in dem Beispiel zu der unbedingten Sprunganweisung kann jeweils die Signatur für die „lade”-Anweisung und für die „vergleiche”-Anweisung zu der Überprüfungsinformation hinzugefügt werden.
  • Bevor die bedingte Sprunganweisung ausgeführt wird, können die Signaturen „2” für die Abzweigung, „1311136867” für den einen nachfolgenden Basisblock, zu dem gesprungen werden kann, und „–1972116585” für den anderen nachfolgenden Basisblock, zu dem gesprungen werden kann, zu der Überprüfungsinformation mittels jeweils einer „push”-Anweisung hinzugefügt werden. Diese Signaturen können zu der Überprüfungsinformation hinzugefügt werden, nachdem die vorangehenden Programm-Anweisungen ausgeführt wurden.
  • Analog kann die Referenz-Überprüfungsinformation bei einem z. B. anderen Ausführen des Programms ermittelt werden. Beim Abarbeiten eines Basisblocks zum Ermitteln der Referenz-Überprüfungsinformation können ein oder mehrere Anweisungen zum Aktualisieren der Referenz-Überprüfungsinformation ausgeführt werden, z. B. die „push”-Anweisungen mit jeweils den Signaturen „2” für die Abzweigung, „1311136867” und „–1972116585” für die nachfolgenden Basisblöcke.
  • Weiterhin kann während einer regulären, zu überprüfenden Ausführung des Programms, bevor die Programm-Sprunganweisung ausgeführt wird, die Überprüfungsinformation mit der Referenz-Überprüfungsinformation verglichen werden, um zu ermitteln, ob bei Ausführung des Basisblocks ein Fehler aufgetreten ist. In dem obigen Beispiel wird hierzu eine „expectedSig”-Anweisung aufgerufen, um zu überprüfen, ob der Basisblock ausgeführt worden ist, der die „lade”-Anweisung, die „vergleiche”-Anweisung und die Abzweige-Anweisung zu den angegebenen Basisblöcken aufweist, wobei in einen dieser Basisblöcke gesprungen werden kann.
  • Gemäß Ausführungsbeispielen kann die Anweisung zum Überprüfen den Akkumulator-Wert mit dem erwarteten Wert vergleichen, der diesem Basisblock zugeordnet ist. Danach kann der Akkumulator zurückgesetzt und aus der Referenz-Überprüfungsinformation ein erwarteter Wert für die nächste Überprüfung ausgewählt werden. Je nachdem wie die Abzweige-Bedingung ausgewertet wird, kann aus der Referenz-Überprüfungsinformation die Basisblock-Signatur des einen oder des anderen Basisblocks ausgewählt werden. Hierzu kann die Abzweige-Bedingung erneut ausgewertet werden oder das zuvor ermittelte Ergebnis der Abzweige-Bedingung verwendet werden. Beispielsweise kann der erwartete Wert auf „1311136867” gesetzt werden, wenn die Bedingung erfüllt ist, und auf „–1972116585” gesetzt werden, wenn die Bedingung nicht erfüllt ist.
  • Gemäß Ausführungsbeispielen kann das Überprüfen der Überprüfungsinformation mit der Referenz-Überprüfungsinformation mittels einer Anweisung ausgeführt werden. Das Initialisieren der Überprüfungsinformation und das Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock abhängig von der Bedingung kann mittels derselben oder einer anderen Anweisung ausgeführt werden.
  • Wenn aufgrund eines Fehlers zu einem falschen Basisblock gesprungen wird, kann dies am Ende der Ausführung des falschen Basisblocks detektiert werden, wenn die Überprüfungsinformation und die Referenz-Überprüfungsinformation nicht übereinstimmen.
  • Wenn zusätzlich ein Fehler beim Auswählen der Basisblock-Signatur aus der Referenz-Überprüfungsinformation auftritt und sowohl die falsche Basisblock-Signatur als Referenz-Überprüfungsinformation gewählt als auch zu diesem falschen Basisblock gesprungen wird, kann dies gemäß dem oben Beschriebenen nicht detektiert werden. Beispielsweise kann die Bedingung richtig als „wahr” ausgewertet werden, jedoch die Basisblock-Signatur des nachfolgenden Basisblocks für den „falsch”-Zweig aus der Referenz-Überprüfungsinformation ausgewählt werden und zu dem Basisblock dieses falschen Zweigs gesprungen werden. Dann können am Ende des falschen Basisblocks die Überprüfungsinformation und die Referenz-Überprüfungsinformation übereinstimmen. Ein derartiger Fehler kann auftreten, wenn der Anweisung zum Überprüfen, ob ein Fehler aufgetreten ist, mehrere Operanden übergeben werden, z. B. Basisblock-Signaturen für die erfüllte und die nicht-erfüllte Bedingung, und die Operanden vertauscht werden.
  • Gemäß Ausführungsbeispielen kann die Basisblock-Signatur eines jeweils nachfolgenden Basisblocks, z. B. des unmittelbar nachfolgenden Basisblocks, mit einer Bit-Maske verknüpft werden, die je nachdem, wie die Bedingung ausgewertet wird, einen unterschiedlichen Wert aufweisen kann. Die Basisblock-Signatur eines jeweils nachfolgenden Basisblocks kann mit der Bit-Maske, z. B. einer mehrstelligen Binärzahl, verknüpft werden, z. B. mittels einer selbstinversen Funktion, z. B. mittels der ausschließlichen Oder-Funktion. Beispielsweise können im Fall einer binären Bedingung für die Auswertungs-Werte „wahr” und „falsch” unterschiedliche Bit-Masken verwendet werden.
  • Gemäß Ausführungsbeispielen kann die Basisblock-Signatur der Referenz-Überprüfungsinformation mittels einer Funktion mit einer Bit-Maske verknüpft werden bevor zum dem nachfolgenden Basisblock gesprungen wird. Nach Ausführen der Programm-Sprunganweisung kann die Bedingung erneut ausgewertet und die Bit-Maske ermittelt werden. Die Basisblock-Signatur der Referenz-Überprüfungsinformation kann danach erneut mit der Bit-Maske verknüpft werden, die dem Ergebnis der Bedingung zugeordnet ist. Im Fall einer selbst-inversen Funktion ergibt sich bei zweifachem Verknüpfen wieder die Basisblock-Signatur. Alternativ kann die aktuelle Signatur der Überprüfungsinformation nach Ausführen der Programm-Sprunganweisung und am Ende des Basisblocks, in den gesprungen wird, mit der ermittelten Bit-Maske verknüpft werden.
  • Falls die Bedingung korrekt ausgewertet wird, aber eine falsche nachfolgende Basisblock-Signatur verwendet wird und zu diesem falschen Basisblock gesprungen wird, kann ein Fehler detektiert werden. Analog kann ein Fehler detektiert werden, wenn die Bedingung falsch ausgewertet wird, aber die richtige nachfolgende Basisblock-Signatur verwendet wird und zu dem richtigen Basisblock gesprungen wird.
  • Gemäß Ausführungsbeispielen kann die Basisblock-Signatur der Referenz-Überprüfungsinformation, z. B. der erwartete Wert, vor und nach Ausführen der Programm-Sprunganweisung mit der jeweils gemäß der Bedingung ermittelten Bit-Maske verknüpft werden.
  • Das folgende Niedriger-Level-Virtuelle-Maschine (Low Level Virtual Machine, LLVM)-Code-Beispiel ist einem Basisblock zugeordnet, der mit einer Programm-Auswahl-Sprunganweisung endet:
    Figure DE102014117971B4_0004
  • Am Ende des Basisblocks, der die Sprunganweisung aufweist, die an eine Auswahlanweisung gekoppelt ist, kann die Basisblock-Signatur der Überprüfungs-Information mit der Signatur für die Auswahlanweisung, z. B. dem Wert „3”, aktualisiert werden. Weiterhin kann die Basisblock-Signatur der Überprüfungsinformation mit jeweils einer Basisblock-Signatur für jeden nachfolgenden und potentiell aufzurufenden Basisblock aktualisiert werden. Analog kann die Referenz-Überprüfungsinformation bei einem z. B. anderen Ausführen des Basisblocks ermittelt werden, indem ein oder mehrere Anweisungen, z. B. „push”-Anweisungen, ausgeführt werden zum Aktualisieren der Referenz-Überprüfungsinformation, die diesem Basisblock zugeordnet ist, mit jeweils einer Basisblock-Signatur für jeden nachfolgenden und potentiell aufzurufenden Basisblock.
  • Bevor die Programm-Sprunganweisung bei einer regulären, zu überprüfenden Ausführung des Programms ausgeführt wird, können die Überprüfungsinformation und die Referenz-Überprüfungsinformation überprüft werden, um zu ermitteln, ob bei Ausführung des Basisblocks ein Fehler aufgetreten ist. In dem obigen Beispiel wird hierzu eine „expectedSig”-Anweisung aufgerufen, um zu überprüfen, ob die Basisblock-Signatur des ausgeführten Basisblocks gemäß der Überprüfungsinformation mit der erwarteten Basisblock-Signatur gemäß der Referenz-Überprüfungsinformation übereinstimmt.
  • Gemäß Ausführungsbeispielen kann die „expectedSig”-Anweisung den Akkumulator-Wert mit dem erwarteten Wert der Referenz-Überprüfungsinformation vergleichen, der diesem Basisblock zugeordnet ist. Danach kann der Akkumulator zurückgesetzt und aus der Referenz-Überprüfungsinformation ein erwarteter Wert für die nächste Überprüfung ausgewählt werden. Aus der Referenz-Überprüfungsinformation kann für die erwartete Basisblock-Signatur je nach dem Ergebnis der Auswertung der Auswahlanweisung, z. B. dem Ergebnis einer Auswahl-Bedingung, eine andere Basisblock-Signatur gewählt werden. Hierzu kann die Auswahl-Bedingung erneut ausgewertet werden oder das zuvor ermittelte Ergebnis der Auswahl-Bedingung verwendet werden.
  • Gemäß Ausführungsbeispielen kann das Überprüfen der Überprüfungsinformation mit der Referenz-Überprüfungsinformation mittels einer Programm-Anweisung ausgeführt werden. Das Initialisieren der Überprüfungsinformation und das Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock gemäß der Auswahl-Bedingung kann mittels derselben oder mindestens einer anderen Programm-Anweisung ausgeführt werden.
  • Gemäß Ausführungsbeispielen kann die Programm-Anweisung zum Initialisieren der Überprüfungsinformation und Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock gemäß der Auswahl-Bedingung eine variadische Anweisung sein, in anderen Worten eine Anweisung mit einer beliebigen Anzahl von Argumenten. Der variadischen Anweisung kann die Anzahl der Argumente mitgeteilt werden, z. B. mittels des ersten Operanden, der übergeben wird.
  • Gemäß Ausführungsbeispielen kann zum Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock ein Ergebnis der Auswahl-Bedingung, oder allgemein ein Ergebnis einer Bedingung, übergeben bzw. übermittelt werden. Zum Auswählen einer Basisblock-Signatur aus der Referenz-Überprüfungsinformation für den als nächstes auszuführenden Basisblock kann jedes Ergebnis der Auswahl-Bedingung übergeben bzw. übermittelt werden. Es kann eine beliebige Anzahl von Ergebnissen der Auswahlbedingung übergeben bzw. übermittelt werden. Beispielsweise kann eine Auswahlbedingung zwei Ergebnisse aufweisen und eine andere Auswahlbedingung kann zehn oder zwanzig Ergebnisse aufweisen.
  • Ferner kann die Auswahlbedingung ein Default-Ergebnis aufweisen, dem eine weitere Basisblock-Signatur zugeordnet ist, die verwendet wird, falls das ermittelte Ergebnis der Auswahlbedingung nicht mit einem der angegebenen Ergebniswerte übereinstimmt.
  • Gemäß Ausführungsbeispielen kann die Basisblock-Signatur der Referenz-Überprüfungsinformation, die dem als nächstes auszuführenden Basisblock zugeordnet ist, vor und/oder nach Ausführen der Programm-Sprunganweisung, z. B. der Programm-Auswahl-Sprunganweisung, mit einer Bit-Maske verknüpft werden, die dem Ergebnis der Auswahl-Bedingung zugeordnet und für jedes Ergebnis verschieden sein kann.
  • Wenn wegen eines Fehlers zu einem falschen Basisblock gesprungen wird, kann dies am Ende der Ausführung dieses falschen Basisblocks detektiert werden, wenn die Überprüfungsinformation und die Referenz-Überprüfungsinformation nicht übereinstimmen.
  • 9 zeigt eine Darstellung 900 des Kontrollflusses zwischen mehreren Basisblöcken gemäß einem Ausführungsbeispiel. Ein erster Basisblock 902 kann mit dem Aufruf einer Programm-Funktion enden. Bei Aufruf der Programm-Funktion kann in den zweiten Basisblock 904 gesprungen werden. Am Ende der Programm-Funktion bzw. des zweiten Basisblocks 904 kann an eine erste Position zurückgesprungen werden, die der Anweisung mit dem Funktionsaufruf aus dem ersten Basisblock 902 heraus folgt. Diese erste Position kann der ersten Anweisung eines dritten Basisblocks 906 zugeordnet werden. Weiterhin kann ein vierter Basisblock 908 mit Aufruf der Funktion enden, welcher der zweite Basisblock 904 zugeordnet ist. Wenn ausgehend von dem vierten Basisblock 908 in den zweiten Basisblock 904 gesprungen wird, kann am Ende des zweiten Basisblocks 904 an eine zweite Position zurückgesprungen werden, die die dem Funktionsaufruf aus dem vierten Basisblock 908 heraus folgt. Diese zweite Position kann einem fünften Basisblock 910 zugeordnet sein.
  • Ein Funktionsaufruf kann als eine unbedingte Programm-Sprunganweisung aufgefasst werden. Der einem Basisblock 902, 908 mit einem Funktionsaufruf nachfolgende Basisblock 904 kann der erste Basisblock der aufgerufenen Funktion sein. Der aufgerufenen Funktion können ein oder mehrere Basisblöcke zugeordnet sein, die ausgeführt werden können, bevor die Ausführung der Funktion endet und zu der Programm-Anweisung gesprungen werden kann, die im Programm-Code dem Funktionsaufruf folgt. Mit dieser Programm-Anweisung startet ein Basisblock 906, 910, der unmittelbar nach dem Funktionsaufruf ausgeführt werden kann.
  • Anschaulich kann eine Programm-Funktion von verschiedenen Positionen innerhalb des Programms aufgerufen werden. Für jede Position kann zu einem jeweils anderen Basisblock zurückgesprungen werden. Der letzte Basisblock 904 einer Programm-Funktion kann ein oder mehrere unmittelbar nachfolgende Basisblöcke 906, 910 aufweisen. Das Rückkehren aus einer Programm-Funktion kann als eine bedingte Programm-Sprunganweisung bzw. eine Programm-Auswahl-Sprunganweisung angesehen werden. Die Basisblock-Signatur des letzten Basisblocks einer Programm-Funktion kann die Basisblock-Signaturen aller der ein oder mehreren unmittelbar nachfolgenden Basisblöcke aufweisen. Bei jedem zurückspringen aus der Programm-Funktion kann die Überprüfungsinformation mit allen der der ein oder mehreren unmittelbar nachfolgenden Basisblock-Signaturen aktualisiert werden.
  • Gemäß alternativen Ausführungsbeispielen kann bei einem Zurückspringen aus der Programm-Funktion die Überprüfungsinformation nur mit der unmittelbar nachfolgenden Basisblock-Signatur des Basisblocks aktualisiert werden, zu dem gesprungen wird, der also unmittelbar nachfolgend ausgeführt wird. In diesem Fall kann die Basisblock-Signatur der Referenz-Überprüfungsinformation, die dem letzten Basisblock der Programm-Funktion zugeordnet ist, auf einen beliebigen Wert gesetzt werden, z. B. einen Zufallswert, denn beim Ermitteln der Referenz-Überprüfungsinformation kann der tatsächlich aufzurufende Basisblock unbekannt sein. Den Basisblöcken, die jeweils dem letzten Basisblock der Programm-Funktion folgen können, kann eine Basisblock-Signatur und ein Korrektur-Wert zugeordnet werden. Alternativ kann den Basisblöcken, die mit dem Funktionsaufruf enden, eine Basisblock-Signatur und ein Korrektur-Wert zugeordnet werden. Der Korrekturwert kann jeweils, egal ob er einem Vorgänger- oder einem Nachfolger-Basisblock der Programm-Funktion zugeordnet wird, auf dem zugewiesenen beliebigen Wert und der ermittelten Basisblock-Signatur des letzten Basisblocks der Programm-Funktion basieren. Die ermittelte Basisblock-Signatur hängt von der Basisblock-Signatur des jeweiligen nachfolgenden Basisblock ab. Wenn der Korrekturwert auf die ermittelte Basisblock-Signatur des letzten Basisblocks der Programm-Funktion angewendet wird, z. B. mittels der Signaturfunktion, kann der beliebige Wert des letzten Basisblocks der Programm-Funktion resultieren.
  • Anschaulich können für jede Position in einem Programm, von der die Programm-Funktion aus aufgerufen wird, der Korrekturwert und die Basisblock-Signatur des Basisblocks gespeichert werden, der nach Rückkehr aus der Funktion, folgt.
  • Das folgende Niedriger-Level-Virtuelle-Maschine (Low Level Virtual Machine, LLVM)-Code-Beispiel zeigt eine interne Programm-Funktion, die zwei Basisblöcke aufweist:
    Figure DE102014117971B4_0005
  • Ein erster Basisblock kann mit der ersten Programm-Anweisung der internen Funktion, z. B. der internen Funktion „Summe” (englisch: sum), starten und mit dem Aufruf einer externen Funktion enden, z. B. der „gebe aus”-Funktion (englisch: printf). Ein zweiter Basisblock kann nach dem Aufruf der externen Funktion „printf” mit der „lade”-Anweisung starten (bzw. mit der „push”-Anweisung, die der „lade”-Anweisung zugeordnet ist und vor der „lade”-Anweisung ausgeführt werden kann) und mit einem Zurückspringen an die Position enden, von der aus die interne Funktion jeweils aufgerufen wird. Bei einer internen Programm-Funktion kann der Programm-Code bekannt sein, bei einer externen Programm-Funktion kann der Programm-Code unbekannt sein.
  • Vor Aufruf der internen Funktion, der als unbedingte Sprunganweisung angesehen kann, kann zu der Überprüfungsinformation eine Signatur für die Programm-Anweisung mit dem Funktionsaufruf hinzugefügt werden, z. B. eine Signatur, die allen Funktionsaufrufen, allen internen Funktionsaufrufen oder dem Aufruf dieser Funktion zugewiesen ist oder alternativ dieselbe Signatur wie für die Abzweigung. Ferner kann eine Signatur für den nachfolgenden Basisblock, zu dem gesprungen werden soll, zu der Überprüfungsinformation hinzugefügt werden. Beides kann z. B. mittels jeweils einer „push”-Anweisung (nicht gezeigt) codiert werden. Der nachfolgende Basisblock kann der erste Basisblock der internen Funktion sein.
  • Ferner können, bevor die interne Funktion aufgerufen wird, die Basisblock-Signatur des Basisblocks, der dem Funktionsaufruf nachfolgt, und der Korrekturwert für den Funktionsaufruf von dieser Position aus der Referenz-Überprüfungsinformation ausgewählt und gespeichert werden. Die nachfolgende Basisblock-Signatur und der Korrekturwert können in einem Speicherbereich gespeichert werden, z. B. einem vorab zugewiesenen Speicherbereich, z. B. einem Stapel (englisch: stack). Die Basisblock-Signatur und der Korrekturwert können mittels einer gemeinsamen Programm-Anweisung oder zwei einzelnen Programm-Anweisungen gespeichert werden.
  • Gemäß alternativen Ausführungsbeispielen können interne Funktionen mit ihrem Programm-Code ersetzt werden, z. B. mittels des „inline”-Befehls in der Programmiersprache C. Auf diese Weise wird die Funktion nicht aufgerufen, sondern ihre Programm-Anweisungen werden ohne den Funktionsaufruf ausgeführt.
  • Gemäß alternativen Ausführungsbeispielen können in einer Tabelle für jeden Funktionsaufruf jeweils der Korrekturwert und die Basisblock-Signatur des nachfolgenden Basisblocks gespeichert werden. Die Tabelle kann die Korrekturwerte und unmittelbar nachfolgenden Basisblock-Signaturen für alle Positionen aufweisen, von denen aus eine Funktion aufgerufen werden kann. Ein Programm kann eine oder mehrere verschiedene Funktionen aufweisen. Für jede dieser Funktionen bzw. für jede Rücksprunganweisung aus einer Funktion kann jeweils eine Tabelle ermittelt werden. Auf einen Eintrag in der Tabelle kann mittels der Rückkehr-Adresse eines jeweiligen Funktionsaufrufs zugegriffen werden, z. B. von innerhalb der Funktion oder innerhalb des mindestens einen Basisblocks, der dem jeweiligen Funktionsaufruf zugeordnet ist, z. B. vor der Programm-Sprunganweisung am Ende des letzten der Funktion zugeordneten Basisblocks. So kann die Überprüfungsinformation mit der Referenz-Überprüfungsinformation überprüft werden und der Funktion des unmittelbar nachfolgenden Basisblocks kann mittels der Tabelle die Basisblock-Signatur der Referenz-Überprüfungsinformation zugeordnet werden.
  • Gemäß Ausführungsbeispielen können dem Funktionsaufruf Parameter hinzugefügt werden, um die nächste Basisblock-Signatur und den Korrekturwert zu übergeben.
  • Gemäß Ausführungsbeispielen können nur die nachfolgende Basisblock-Signatur und der Korrekturwert des jeweils auszuführenden Funktionsaufrufs in einem Speicherbereich gespeichert werden, z. B. in dem Stapels des Funktionsaufrufs oder in einem Speicherbereichs, der von dem Stapel des Funktionsaufrufs getrennt ist, z. B. einem zusätzlichen Stapel. So kann Speicherplatz gespart werden, weil nur Werte für den jeweils auszuführenden Funktionsaufruf gespeichert werden bis aus der Funktion zurückgekehrt wird, anstelle die Werte für alle Funktionsaufrufe während der Programm-Ausführung zu speichern.
  • Ferner fügt ein separater Speicherbereich oder Stapel für die Korrekturwerte und nachfolgenden Basisblock-Signaturen Redundanz hinzu. Falls aufgrund eines Fehlers auf einen falschen Speicherbereich oder einen falschen Rahmen eines Stapels zugegriffen wird, können die Informationen nicht zusammenpassen, die aus dem Stapel des Funktionsaufrufs und aus dem Speicherbereich oder Stapel für die Korrekturwerte und nachfolgenden Basisblock-Signaturen geladen werden. Beispielsweise kann aufgrund eines Fehlers zu einem anderen Basisblock zurückgesprungen werden als zu dem Basisblock, dessen Signatur als nachfolgende Basisblock-Signatur aus dem Speicher geholt wird. Es ist sehr unwahrscheinlich, dass aufgrund mehrerer Fehler ein falscher Korrekturwert, eine falsche Basisblock-Signatur und eine falsche Rücksprung-Position, z. B. Rücksprungadresse, verwendet werden, die zu dem falschen nachfolgenden Basisblock passen.
  • Gemäß Ausführungsbeispielen können der Korrekturwert und die nachfolgende Basisblock-Signatur der Programm-Sprunganweisung zugeordnet sein, z. B. einer Programm-Rücksprunganweisung.
  • Nachdem die interne Funktion ausgeführt wurde, kann zu der Programm-Anweisung gesprungen werden, die dem internen Funktionsaufruf folgt. Vor dem Zurückspringen, also dem Ausführen einer Programm-Rücksprunganweisung, kann der Korrekturwert aus dem Speicher geladen werden, z. B. an oberster Position aus dem Stapel geholt und dort entfernt werden. Dieser Korrekturwert kann zu der Überprüfungsinformation, die dem letzten Basisblock der Programm-Funktion zugeordnet ist, hinzugefügt werden, z. B. kann der Akkumulator-Wert mittels des Korrekturwerts aktualisiert werden. Ferner kann die Basisblock-Signatur des Basisblocks, der nach dem Funktionsaufruf ausgeführt wird, aus dem Speicher geladen werden, z. B. an oberster Position aus dem Stapel geholt und dort entfernt werden, um den erwarteten Wert auf diese Basisblock-Signatur zu setzen bzw. allgemein ausgedrückt, um dem nachfolgenden Basisblock die Basisblock-Signatur der Referenz-Überprüfungsinformation zuzuordnen.
  • Gemäß Ausführungsbeispielen kann ein externer Funktionsaufruf wie eine Programm-Anweisung behandelt werden. Vor Ausführen des Funktionsaufrufs kann eine Signatur für den Funktionsaufruf zu der Überprüfungsinformation hinzugefügt werden. Nach Ausführen des Funktionsaufrufs, z. B. am Ende des Basisblocks, der die Anweisung mit dem Funktionsaufruf aufweist, kann die Überprüfungsinformation mit der Referenz-Überprüfungsinformation verglichen werden. Ferner kann die Überprüfungsinformation zurückgesetzt werden und für den nächsten Basisblock der erwartete Wert aus der Referenz-Überprüfungsinformation ausgewählt werden. Anschaulich kann nach dem Aufruf der externen Funktion ein Basisblock enden und mit der Programm-Anweisung, die der externen Funktion folgt, ein nächster Basisblock beginnen. Bevor in den nächsten Basisblock gesprungen wird, können die Überprüfungsinformation und die Referenz-Überprüfungsinformation überprüft werden.
  • Gemäß Ausführungsbeispielen können die Überprüfungsinformation und die Referenz-Überprüfungsinformation überprüft werden, bevor die externe Funktion aufgerufen wird, wie in dem obigen Code-Beispiel gezeigt. Der externe Funktionsaufruf kann einer unbedingten Programm-Sprunganweisung entsprechen. Der nächste Basisblock kann mit der Programm-Anweisung beginnen, die dem externen Funktionsaufruf unmittelbar folgt. Vor Aufruf der externen „gebe aus”-Funktion (englisch: printf) kann die Signatur mit dem Wert „48” für die „gebe aus”-Funktion zu der Überprüfungsinformation hinzugefügt werden. Danach kann die Basisblock-Signatur „–304077700” für den nachfolgenden Basisblock zu der Überprüfungsinformation hinzugefügt werden. Die Überprüfungsinformation und die Referenz-Überprüfungsinformation können überprüft werden. Danach kann die Überprüfungsinformation initialisiert werden und aus der Referenz-Überprüfungsinformation kann die Basisblock-Signatur für den nachfolgenden Basisblock ausgewählt werden, z. B. kann der erwartete Wert auf „–304077700” gesetzt werden.
  • Falls der Kontrollfluss vor dem Ausführen der externen Funktion verändert werden sollte, z. B. aufgrund eines Fehlers, kann dies detektiert werden, bevor die externe Funktion ausgeführt wird. So können beispielsweise falsche Ausgaben, z. B. auf ein externes Gerät oder in einen Speicher, verhindert werden.
  • Gemäß Ausführungsbeispielen kann ein rekursiver Funktionsaufruf einer Schleife entsprechen, in der ein Basisblock sich selbst aufruft.
  • Bei einem Funktionsaufruf kann ein Fehler in dem Funktionsaufruf auftreten. Dann kann eine falsche Funktion oder gar keine Funktion aufgerufen werden, was dem Aufruf eines falschen Basisblocks entspricht. Weiterhin kann ein Fehler beim Zurückspringen aus der Funktion auftreten. Auch bei diesem Fehler kann ein falscher Basisblock aufgerufen werden.
  • 10 zeigt eine Darstellung 1000 des Kontrollflusses zwischen mehreren Basisblöcken gemäß einem Ausführungsbeispiel. Ein erster Basisblock 1002 kann mit dem Aufruf einer Programm-Funktion mittels eines Zeigers auf eine auszuführende Funktion, Funktionszeiger genannt, enden. Je nach Inhalt des Funktionszeigers kann eine Programm-Funktion aus ein oder mehreren Programm-Funktionen aufgerufen werden. Bei einem ersten Ausführen des Programm-Codes, der dem ersten Basisblock 1002 zugeordnet ist, kann der Funktions-Zeiger auf eine Funktion zeigen, der ein zweiter Basisblock 1004 gefolgt von einem dritten Basisblock 1006 zugeordnet ist. Am Ende des dritten Basisblocks 1006 kann in einen vierten Basisblock 1008 zurückgesprungen werden, der im Programm-Code dem Funktionsaufruf unmittelbar nachfolgt. Sei einem zweiten Ausführen des ersten Basisblocks 1002 kann der Funktions-Zeiger auf eine andere Funktion zeigen, der ein fünfter Basisblock 1010 zugeordnet ist. Am Ende des fünften Basisblocks 1010 kann in den vierten Basisblock 1008 zurückgesprungen werden, der im Programm-Code dem Funktionsaufruf unmittelbar nachfolgt.
  • Anschaulich kann es von der Ausführung des Programms, in anderen Worten von der Laufzeit, abhängen, auf welche Funktion der ein oder mehreren Funktionen der Funktionszeiger zeigt. Je nachdem auf welche Funktion der Funktionszeiger zeigt, können ein oder mehrere unterschiedliche Basisblöcke 1004, 1006, 1010 ausgeführt werden. Am Ende des letzten Basisblocks der jeweils ausgeführten Funktion kann in denselben Basisblock 1008 zurückgesprungen werden, es kann also dem Funktionsaufruf unter Verwendung des Funktionszeigers derselbe Basisblock 1008 folgen.
  • Gemäß Ausführungsbeispielen kann je nachdem, von welcher Position im Programm oder welchem Basisblock eine Funktion mittels Funktionszeiger aufgerufen wird, ein anderer Basisblock dem Funktionsaufruf unmittelbar folgen.
  • Gemäß Ausführungsformen kann ein Funktionszeiger mit einer Sequenz von vorbestimmten Funktionsaufrufen ersetzt werden, wobei ein jeweiliger Funktionsaufruf die gleiche Funktionssignatur, auch als Typinformation bezeichnet, z. B. die gleiche Anzahl von Operanden des gleichen Typs, wie die Funktion aufweist, die mittels des Funktionszeigers aufgerufen werden kann. Die Sequenz der Funktionsaufrufe kann Vergleiche des Inhalts oder der Adresse, den oder die der Funktionszeiger aufweist, mit den Adressen von vorbestimmten Funktionen gleicher Funktionssignatur aufweisen. Wenn die Adressen übereinstimmen kann die jeweilige vorbestimmte Funktion aufgerufen werden.
  • Ein Funktionszeiger kann mit einer Sequenz der Funktionsaufrufe derselben Funktionssignatur ersetzt werden, die der Programm-Code aufweist. Dann kann ein Funktionszeiger zwei Funktionsaufrufen entsprechen: einem ersten Funktionsaufruf zu der Funktion mit der Sequenz der Funktionsaufrufe und einem zweiten Funktionsaufruf der mittels der Vergleiche ausgewählten Funktion.
  • Gemäß Ausführungsformen kann ein Funktionszeiger mit jeder Funktion verglichen werden, die das Programm, z. B. binäre Programm, aufweist, z. B. mit jeder Funktion deren Funktionssignatur unbekannt ist.
  • Gemäß Ausführungsformen kann eine Tabelle mit den Adressen aller Funktionen und der jeweils zugehörigen Signaturinformation gespeichert werden. Während das Programm ausgeführt wird, kann mittels der Adresse des Funktionszeigers auf die zugehörige Signatur zugegriffen werden. Die Tabelle mit den Adressen aller Funktionen und der jeweils zugehörigen Signaturinformation kann für jeden Funktionsaufruf mittels Funktionszeiger gespeichert werden. Für jeden Funktionsaufruf mittels Funktionszeiger können zwei Basisblock-Signaturen und zwei Korrekturwerte gespeichert werden, jeweils ein Korrekturwert und eine Basisblock-Signatur für den ersten und für den letzten Basisblocks innerhalb der aufzurufenden Funktion.
  • Gemäß Ausführungsformen können alle Funktionsaufrufe, die unter Verwendung eines Funktionszeigers erfolgen, durch eine Funktion, z. B. eine variadische Funktion, ersetzt werden, der als Parameter die Adresse der aufzurufenden Funktion und die Argumente der aufzurufenden Funktion übergeben werden. Diese Funktion kann als Dispatcher-Funktion bezeichnet werden und kann mittels der übergebenen Adresse die beabsichtigte Funktion aufrufen. Auf diese Weise kann es in dem Programm nur eine Position geben, von der aus der Funktionszeiger verwendet wird, um eine Funktion aufzurufen. Anschaulich kann egal, von welcher Position im Programm (nicht dargestellt) die Dispatcher-Funktion aufgerufen wird, immer derselbe Basisblock 1002 unmittelbar folgen und erst in diesem nachfolgenden Basisblock 1002 folgt je nachdem, welche Adresse mittels des Funktionszeiger aufgerufen werden soll, ein jeweils anderer Basisblock 1004, 1010. Die Dispatcher-Funktion endet immer mit demselben Basisblock 1008, dem wie bei einem Funktionsaufruf der Basisblock (nicht dargestellt) nachfolgt, der dem jeweiligen Dispatcher-Funktionsaufruf unmittelbar nachfolgt.
  • Weil der Funktionszeiger nur von einer Position im Programm verwendet wird, kann nur eine Tabelle mit den Adressen aller Funktionen und der jeweils zugehörigen Signaturinformation benötigt werden. Wenn das Programm mehr als einen Funktionsaufruf mittels Funktionszeiger aufweist, ist es effizienter jeweils die Dispatcher-Funktion aufzurufen und so eine einzige Tabelle zu speichern als für jeden Funktionsaufruf mittels Funktionszeiger eine eigene Tabelle zu speichern.
  • Gemäß Ausführungsformen können die dem ersten Basisblock 1002 der Dispatcher-Funktion nachfolgende Signatur und/oder die Signatur des Basisblocks, der dem letzten Basisblock 1010 der Dispatcher-Funktion vorausgeht, weggelassen werden. Dann können keine Korrekturwerte benötigt werden und die Größe der Tabelle kann reduziert werden. Jedoch kann in diesem Fall nicht überprüft werden, ob mittels des Funktionszeigers die richtige Funktion aufgerufen wird und/oder ob zu der Dispatcher-Funktion zurückgekehrt wird.
  • Der Kontrollfluss eines Programms kann als Graph des Kontrollflusses zwischen den Basisblöcken dargestellt werden, wie in den 8, 9 und 10 gezeigt. Zum Ermitteln der Referenz-Überprüfungsinformation kann der Kontrollfluss-Graph mit den Basisblöcken von oben herab (englisch: top-down) oder von unten herauf (englisch: bottom-up) traversiert oder durchlaufen werden.
  • Gemäß Äusführungsbeispielen kann das Ermitteln der Referenz-Überprüfungsinformation bei einem ersten Knoten des Kontrollfluss-Graphen starten, der dem als erstes auszuführenden Basisblock des Programms entspricht. Wenn ein Knoten des Graphen, der einem Basisblock zugeordnet ist, besucht wird, kann die Basisblock-Signatur mittels der Signaturen berechnet werden, die den Anweisungen des besuchten Basisblocks zugeordnet sind. Danach können die Knoten der unmittelbar nachfolgenden Basisblöcke mittels rekursiver Funktionsaufrufe besucht und deren Signaturen berechnet werden. Wenn ein rekursiver Funktionsaufruf zurückkehrt, kann die Basisblock-Signatur des aktuellen Knotens mit der ermittelten Basisblock-Signatur dieses Nachfolgers aktualisiert werden.
  • Jedes Mal, wenn ein Knoten besucht wird, kann ermittelt werden, ob der besuchte Knoten oder ein Nachfolger-Knoten der erste Knoten einer Schleife ist. Besuchte Knoten können als besucht markiert werden. Wenn der Knoten erneut besucht wird, kann ermittelt werden, ob er bereits besucht worden ist.
  • Wenn ein Nachfolger-Knoten eines aktuell besuchten Knotens der erste Knoten einer Schleife ist, z. B. der Nachfolger als besucht markiert ist, kann der aktuell besuchte Knoten der letzte Knoten der Schleife sein. Wenn der aktuelle Knoten zum ersten Mal als letzter Knoten einer Schleife besucht wird, kann der Basisblock-Signatur des aktuell besuchten Knotens ein beliebiger Wert zugewiesen werden, z. B. ein Zufallswert. Weiterhin kann der Knoten als letzter Knoten der Schleife markiert oder gespeichert werden.
  • Wenn der aktuell besuchte Knoten der erste Knoten einer Schleife ist, z. B. bereits als besucht markiert ist, sollte ein Korrekturwert für den letzten Knoten der Schleife berechnet werden. Nachdem Basisblock-Signaturen aller Nachfolger-Knoten des aktuell besuchten Knotens ermittelt worden sind, können für die ein oder mehreren Nachfolger-Knoten, die letzte Knoten einer Schleife sind, Korrekturwerte ermittelt werden.
  • Das Schützten des Kontrollflusses einer Anwendung oder eines Programms, d. h. das ihr oder ihm Ermöglichen, Code sicher zu verarbeiten, kann zu verschiedenen Abschnitten der Lebensdauer der Anwendung oder des Programms erfolgen: vor dem Compilieren durch Schützten des Quell-Codes, während des Compilierens durch Schützen einer Zwischen-Repräsentation des Programms, oder zur Laufzeit durch Schützen des Binär-Programms (englisch: Binary) während der Ausführung. Unabhängig davon, ob die Referenz-Überprüfungsinformation vor dem Compilieren, während dem Compilieren oder zur Laufzeit ermittelt wird, können die Basisblock-Signaturen und gegebenenfalls die Korrekturwerte für eine Code-Überprüfung berechnet werden. Es werden Schleifen, geschachtelte Kontrollfluss-Strukturen auf Quell-Code-Ebene, Funktionsaufrufe und Funktionsaufrufe mittels Funktionszeigern unterstützt.
  • Gemäß Ausführungsformen können alle Programmier-Sprachen, für die ein Zwischen-Code-Compiler existiert, beispielsweise C, unterstützt werden. Ausführungsformen sind aber nicht auf diese Programmiersprachen beschränkt.
  • Es kann ein Interpreter für ein als Binär-Programm gegebenes Programm bereitgestellt werden. So können beliebige Programme mit beliebigem Kontrollfluss geschützt werden. Die Basisblock-Signaturen können zur Laufzeit ermittelt werden.
  • Ein Interpreter ermöglicht die Ausführung eines Programms ohne es in Maschinen-Code zu kompilieren. In diesem Fall muss das Programm nicht modifiziert werden. Der Interpreter kann das Programm laden, die Referenz-Überprüfungsinformation, z. B. die um Überprüfen benötigten Basisblock-Signaturen, und die Überprüfungsinformation berechnen. Weiterhin kann der Interpreter überprüfen, ob ein Fehler aufgetreten ist.
  • 11 zeigt eine Datenverarbeitungsanordnung 1100 gemäß einem Ausführungsbeispiel. Quellcode 1102 kann einem Compiler 1104 (beispielsweise einem Software-Codier-Compiler) zugeführt werden. Der Compiler 1104 kann dann eine sichere Programmvariante 1106 und erwartete Basisblock-signaturen 1120 erzeugen. Durch Übersetzen, beispielsweise einschließlich Linken, wird die sichere Programmvariante 1106 in ein ausführbares geschütztes Programm 1108 überführt, das beispielsweise auf Standard-Hardware und einem Standard-Betriebssystem 1112 ausgeführt werden kann. Es kann eine geschützte Ausführung 1110 des ausführbaren geschützten Programms 1108 stattfinden. Akkumulierte Basisblock-Signaturen 1116 des ausführbaren geschützten Programms 1108 können während der geschützten Ausführung 1110 an den sicheren Watchdog (anders ausgedrückt einem sicheren Überprüfungs-Schaltkreis 1118) gesendet und überprüft werden, indem sie mit den erwarteten Basisblock-Signaturen 1120 verglichen werden. Optional können Ausgabewerte 1114 des ausführbaren geschützten Programms 1108 können durch den sicheren Watchdog 1118 verifiziert bzw. freigegeben werden, dargestellt durch Pfeil und Kreis 1122, und erst ausgegeben werden, wenn der sichere Watchdog 1118 die akkumulierten Basisblock-Signaturen 1118 zur Überprüfung des Kontrollflusses verifiziert hat. Ferner können zur Überprüfung eines Datenflusses die Ausgabewerte mittels arithmetischen Codes codiert sein und auf eine gültige Codierung hin überprüft werden oder es können weitere akkumulierte Signaturen (nicht dargestellt), z. B. mittels arithmetischer Codes codierte Signaturen, zur Überprüfung des Datenflusses an den oder einen weiteren sicheren Watchdog gesendet werden.
  • Stimmen die akkumulierten Basisblock-Signaturen 1116 oder weitere akkumulierte Signaturen (nicht dargestellt) nicht mit den erwarteten Signaturen überein, kann der Watchdog ermitteln, dass ein Fehler aufgetreten ist und beispielsweise die Ausführung des gesicherten Anwendung abbrechen oder herunterfahren. Weiterhin kann der Überprüfungsschaltkreis die Anwendung beenden, wenn sie aufhört, Werte zu senden (was mittels eines Zeitlimits (englisch: timeout) ermittelt werden kann.
  • Gemäß Ausführungsformen können die ermittelten Basisblock-Signaturen als Referenz-Überprüfungsinformation in dem Watchdog bzw. dem sicheren Überprüfungsschaltkreis gespeichert werden.
  • Gemäß Ausführungsformen kann der Programm-Code nur modifiziert werden, wenn Funktionsaufrufe mittels Funktionszeigern überprüft werden sollen.
  • Gemäß alternativen Ausführungsformen können die ermittelten Basisblock-Signaturen in dem ausführbaren geschützten Programm-Code eingefügt werden bzw. so gespeichert werden, dass die Anwendung beim Ausführen des Programm-Codes auf diese zugreifen kann zum Aktualisieren der Überprüfungsinformation mit einer nachfolgenden Basisblock-Signatur. Die ermittelten Basisblock-Signaturen, anders ausgedrückt die Referenz-Überprüfungsinformation, können an den Überprüfungsschaltkreis übermittelt werden, z. B. jeweils die Referenz-Basisblock-Signatur für die nächste Überprüfung, z. B. der erwartete Wert.
  • Gemäß Ausführungsformen können die Signaturen für die Programm-Anweisungen beim Ermitteln der Referenz-Überprüfungsinformation und/oder der Überprüfungsinformation gemäß denselben Regeln ermittelt werden, z. B. basierend dem Befehls-Code der Programm-Anweisungen oder als Zufallszahlen. Die Signaturen für die Programm-Anweisungen können ferner einmalig ermittelt werden und gespeichert oder in den ausführbaren Programm-Code eingefügt werden. Nach dem Ermitteln der Referenz-Überprüfungsinformation werden die Signaturen für die Programm-Anweisungen nur zum Ermitteln der Überprüfungsinformation benötigt. Signaturen für einzelne Programm-Anweisungen werden nicht für z. B. einen Vergleich beim Überprüfen benötigt.
  • Gemäß Ausführungsformen können bei einer Hardware-basierten Implementierung die Programm-Anweisungen als Signaturen für die Programm-Anweisungen verwendet werden, z. B. die kompilierten Programm-Anweisungen oder die Programm-Anweisungen in Maschinensprache, die Speicher- und Register-Adressen neben anderen Parametern wie dem Namen der Programm-Anweisung aufweisen können.
  • Gemäß alternativen Ausführungsformen können die Signaturen für die Programm-Anweisungen statisch während des Transformationsprozesses erzeugt werden und vom Programm völlig unabhängige, zufällig wählbare Werte beliebiger Größe und 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.
  • 12 zeigt eine Darstellung 1200 eines Prozessors 1202 gemäß Ausführungsformen. Der Überprüfungsschaltkreis (nicht dargestellt) kann als Erweiterung des Befehlssatzes eines Prozessors, z. B. einer zentralen Verarbeitungseinheit, implementiert sein.
  • 13 zeigt eine Darstellung 1300 gemäß weiteren Ausführungsformen. Der Überprüfungsschaltkreis kann als Aufpasser-Einheit 1302 außerhalb des Befehlssatzes eines Prozessors 1304, z. B. einer zentralen Verarbeitungseinheit, implementiert sein.
  • 14 zeigt eine Darstellung 1400 gemäß weiteren Ausführungsformen. Ein Prozessor 1402 mit einem Cache-Speicher kann eine Schnittstelle aufweisen und mittels der Schnittstelle Programm-Anweisungen 1404 an den Überprüfungsschaltkreis 1406 zum Überprüfen senden, die mittels des Prozessors ausgeführt werden. Der Überprüfungsschaltkreis 1406 kann an den Prozessor 1402 Befehle senden, z. B. Befehle zum Initialisieren der Überprüfungsinformation, z. B. dem Akkumulator, und zum Setzen der nächsten erwarteten Referenz-Basisblock-Signatur.
  • Gemäß Ausführungsformen kann ein Überprüfungs-Schaltkreis verwendet werden zum Überprüfen der korrekten Ausführung des geschützten Programms während seiner Laufzeit. Er kann außerhalb des geschützten Programms angeordnet sein, also beispielsweise kein Teil des geschützten Programms sein. Gemäß Ausführungsformen kann der Überprüfungs-Schaltkreis zuverlässig außerhalb des geschützten Programms ausgeführt werden.
  • Gemäß Ausführungsformen kann die einfache Implementierung die Anwendung von verschiedenen Mechanismen unterstützen um ihre Ausführung sicher zu machen, beispielsweise redundante Ausführung auf verschiedener Hardware wie beispielsweise onboard FPGAs (onboard Field Programmable Gate Array; deutsch: Feld-Programmierbare-Gatter-Anordnung auf der Hauptplatine) oder Grafikeinheiten. Zusätzlich können gemäß Ausführungsformen mehrere Überprüfungs-Schaltkreise parallel bereitgestellt werden, um das Risiko eines fehlerhaften Überprüfungs-Schaltkreises weiter zu reduzieren.
  • Im folgenden werden Auswertungen von Verfahren und Datenverarbeitungsanordnungen gemäß Ausführungsformen unter Verwendung der folgenden Anwendungen beschrieben: md5 berechnet den md5-Hash einer Zeichenkette (englisch: string), bubble sort sortiert eine Liste von ganzzahligen Werten, gzip komprimiert eine Datei.
  • 15 zeigt eine Darstellung 1500 der detektierten Fehler unter Verwendung der Algorithmen md5, bubble sort und gzip. Pro Durchlauf des Programms wurde jeweils ein Fehler an einer zufälligen Position in das ausgeführte Programm eingefügt. Die folgenden Fehler wurden eingefügt (die Ergebnisse sind in den Zeilen der 15 dargestellt): nicht ausgeführte Programm-Anweisung (SI), zweifach ausgeführte Programm-Anweisung (RI), Sprung zu einer zufällig ausgewählten Programm-Anweisung (RJ), Ausführen des falschen Programm-Zweigs (MBr), Sprung zum Anfang desselben Basisblocks (ES), zur Mitte desselben Basisblocks (MS), zum Anfang eines anderen Basisblocks (BO) und zur Mitte eines anderen Basisblocks (MS), beschädigte Programm-Anweisung (CI) z. B. aufgrund eines Bit-Flips und Aufruf einer falschen Funktion (CC). In den Balkendiagrammen der ersten Spalte ist dargestellt, wie viele Fehler detektiert werden, wenn der Kontrollfluss nicht geschützt wird. Ohne Schutz mittels Basisblock-Signaturen haben insgesamt 31% aller eingefügten Fehler die Ausführung des Programms beeinflusst, indem sie zu einem falschen bzw. gar keinen Ergebnis oder einem Timeout bzw. Abbrechen des Programms führten, ohne detektiert zu werden. Wenn der Kontrollfluss mittels den oben beschriebenen Basisblock-Signaturen geschützt wurde, wurden alle injizierten Fehler entweder beim Überprüfen der Basisblock-Signaturen detektiert oder die Programm-Ausführung wurde von dem Betriebssystem abgebrochen. Bei 2,52% der injizierten Fehler die Programm-Ausführung von dem Betriebssystem abgebrochen. Alle restlichen injizierten Fehler wurden vor Ausführen einer Anweisung mittels der Basisblock-Signaturen detektiert, bevor das Betriebssystem die Programmausführung abbrechen konnte.
  • Kontrollfluss-Überprüfung, welche in Hardware oder Software implementiert werden kann, stellt Mittel bereit zum Erkennen ungültigen Kontrollflusses für das ausgeführte Programm, d. h. Ausführung von Sequenzen von Instruktionen, die nicht erlaubt sind für das ausgeführte Programm. Im Gegensatz zu einer Codierung mittels arithmetischer Codes erkennt Kontrollfluss-Überprüfung keine Fehler, die nur die verarbeiteten Daten beeinflussen. Die Kontrollfluss-Überprüfung kann sowohl innerhalb eines Basisblocks als auch für Inter-Basisblock-Kontrollfluss durchgeführt werden. Gemäß Ausführungsformen können mittels Basisblock-Signaturen geschützte Programme auf der Instruktions-Ebene und/oder auf der Basisblock-Ebene überprüft werden.
  • Es kann vorteilhaft sein, beim Schutz von Programmen Verfahren für den Schutz des Datenflusses und Verfahren für den Schutz des Kontrollflusses getrennt voneinander zu implementieren und bei Bedarf in Kombination miteinander einzusetzen. Gemäß Ausführungsformen wird ein Codier-Compiler oder ein Interpreter für den Schutz des Kontrollflusses eines Programms bereitgestellt. Je nach Art der Programm-Sprunganweisung und/oder je nach Sicherheitsanforderung, z. B. niedriger oder hoher Sicherheit, können ein, mehrere oder alle der unmittelbar nachfolgenden Basisblöcke beim Ermitteln der Basisblock-Signaturen berücksichtigt werden. Die Basisblock-Signaturen werden beim Compilieren oder Interpretieren als Referenz-Überprüfungsinformation ermittelt. Zur Laufzeit werden diese bereits ermittelten Basisblock-Signaturen als nachfolgende Basisblock-Signaturen beim Ermitteln der Überprüfungsinformation und zum Überprüfen des Kontrollflusses berücksichtigt.
  • Ferner können je nach Art der Programm-Sprunganweisung und/oder je nach Sicherheitsanforderung nachfolgende Basisblock-Signaturen und/oder Programm-Anweisungen innerhalb eines Basisblocks beim Ermitteln der Basisblock-Signatur berücksichtigt werden oder nicht. Daher kann die Fehler-Erkennungs-Rate gegen die Laufzeit-Kosten abgewogen werden.
  • Gemäß Ausführungsbeispielen wird beliebiger Kontrollfluss unterstützt, der zu der Zeit des Ermittelns der Referenz-Überprüfungsinformation nicht vorhersagbar ist, z. B. zu der Zeit des Compilierens. Zur Laufzeit, wenn die Überprüfungsinformation ermittelt wird, können Fehler im Kontrollfluss detektiert werden.
  • 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 erneuten Ausführung.
  • Gemäß Ausführungsformen kann ein Fehler-Erkennungs-Ansatz bereitgestellt werden basierend auf Basisblock-Signaturen, der Software und/oder Hardware-basierte Ende-zu-Ende Fehler-Erkennung von Hardware-Fehlern unterstützt. Seine Fehler-Erkennungs-Möglichkeiten können entkoppelt sein von der eingesetzten Hardware.

Claims (22)

  1. Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, das Verfahren aufweisend: • Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Ermitteln einer Basisblock-Signatur zumindest des zweiten Basisblocks aus einer Referenz-Überprüfungsinformation des zweiten Basisblocks; • Ermitteln von Überprüfungsinformation zumindest des ersten Basisblocks während der Ausführung des ersten Basisblocks basierend auf der Basisblock-Signatur des ersten Basisblocks, wobei die Basisblock-Signatur des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und zumindest der Basisblock-Signatur des zweiten Basisblocks, gemäß der Referenz-Überprüfungsinformation zumindest des zweiten Basisblocks, ermittelt wird; • Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation; • Setzen der Referenz-Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  2. Verfahren gemäß Anspruch 1, wobei die Referenz-Überprüfungsinformation des mindestens einen Basisblocks vor Ausführung des jeweiligen Basisblocks ermittelt wird.
  3. Verfahren gemäß einem der Ansprüche 1 bis 2, wobei die Signaturfunktion eine kryptographische Signaturfunktion ist.
  4. Verfahren gemäß Anspruch 3, wobei die kryptographische Signaturfunktion eine kryptographische Hash-Funktion ist.
  5. Verfahren gemäß einem der Ansprüche 3 bis 4, wobei die Signaturfunktion ermittelt wird, indem die jeweilige Programm-Anweisung oder die nachfolgende Basisblock-Signatur mit dem von der Signaturfunktion unmittelbar zuvor berechneten Wert verknüpft wird.
  6. Verfahren gemäß einem der Ansprüche 1 bis 5, wobei ermittelt wird, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, bevor der mindestens eine nachfolgende Basisblock aufgerufen wird.
  7. Verfahren gemäß einem der Ansprüche 1 bis 6, ferner aufweisend: Initialisieren eines Akkumulator-Werts mit einem Initialisierungs-Wert.
  8. Verfahren gemäß Anspruch 7, wobei das Initialisieren des Akkumulator-Werts und das Setzen der erwarteten Überprüfungsinformation auf die Referenz-Überprüfungsinformation des zweiten Basisblocks gemeinsam atomar ausgeführt wird.
  9. Verfahren gemäß Anspruch 7 oder 8, aufweisend Aktualisieren des Akkumulator-Werts basierend auf der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock, wenn der jeweilige Basisblock ausgeführt wird.
  10. Verfahren gemäß Anspruch 9, wobei das Aktualisieren des Akkumulator-Werts basierend auf der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ein Aktualisieren des Akkumulator-Werts mit der Basisblock-Signatur des nachfolgenden Basisblock aufweist, der als nächstes ausgeführt werden soll.
  11. Verfahren gemäß einem der Ansprüche 9 oder 10, wobei der Akkumulator-Wert mit der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock am Ende des jeweiligen Basisblocks aktualisiert wird, bevor zu mindestens einem nachfolgenden Basisblock gesprungen wird.
  12. Verfahren gemäß einem der Ansprüche 7 bis 11, aufweisend Überprüfen des Akkumulator-Werts basierend auf der erwarteten Überprüfungsinformation, zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist.
  13. Verfahren gemäß Anspruch 12, wobei ermittelt wird, dass bei der Ausführung des Programms ein Fehler aufgetreten ist, wenn der Akkumulator-Wert und die erwartete Überprüfungsinformation nicht übereinstimmen.
  14. Verfahren gemäß einem der Ansprüche 1 bis 13, ferner aufweisend Ermitteln der Referenz-Überprüfungsinformation in einem Überprüfungs-Schaltkreis.
  15. Verfahren gemäß Anspruch 14, aufweisend Übermitteln der ermittelten Überprüfungsinformation an einen Überprüfungsschaltkreis zum Ermitteln, ob bei einer Ausführung des Programm-Codes ein Fehler aufgetreten ist, basierend auf der Überprüfungsinformation und der Referenz-Überprüfungsinformation.
  16. Verfahren gemäß einem der Ansprüche 12 bis 15, wobei der Überprüfungs-Schaltkreis außerhalb des Programms implementiert ist.
  17. Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, das Verfahren aufweisend: • Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Empfangen von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis, wobei die Überprüfungsinformation auf der Basisblock-Signatur des jeweiligen Basisblocks basiert, wobei die Basisblock-Signatur zumindest des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur von mindestens dem zweiten Basisblock, gemäß einer Referenz-Überprüfungsinformation des zweiten Basisblocks, ermittelt wird, der dem jeweiligen Basisblock unmittelbar nachfolgt; • Ermitteln in dem Überprüfungsschaltkreis, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz-Überprüfungsinformation; • Setzen der Referenz-Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  18. Verfahren zur Datenverarbeitung zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, das Verfahren aufweisend: • Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Erzeugen eines Programm-Code-Abschnittes zum Ermitteln einer Basisblock-Signatur zumindest des zweiten Basisblocks aus einer Referenz-Überprüfungsinformation des zweiten Basisblocks; • Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Überprüfungsinformation zumindest des ersten Basisblocks während der Ausführung des ersten Basisblocks basierend auf der Basisblock-Signatur des ersten Basisblocks, wobei die Basisblock-Signatur des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und zumindest der Basisblock-Signatur des zweiten Basisblocks, gemäß der Referenz-Überprüfungsinformation zumindest des zweiten Basisblocks, ermittelt wird; • Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation • Erzeugen eines Programm-Code-Abschnittes zum Setzen der Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  19. Vorrichtung zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, aufweisend: • Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis, der eingerichtet ist zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • wobei der Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis weiter eingerichtet ist zum Ermitteln einer Basisblock-Signatur zumindest des zweiten Basisblocks aus einer Referenz-Überprüfungsinformation des zweiten Basisblocks; • Überprüfungsinformation-Ermittlungs-Schaltkreis, der eingerichtet ist zum Ermitteln von Überprüfungsinformation zumindest des ersten Basisblocks während der Ausführung des ersten Basisblocks basierend auf der Basisblock-Signatur des ersten Basisblocks, wobei die Basisblock-Signatur des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und zumindest der Basisblock-Signatur des zweiten Basisblocks, gemäß der Referenz-Überprüfungsinformation zumindest des zweiten Basisblocks, ermittelt wird; • Überprüfungsschaltkreis, der eingerichtet ist zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation; • Setzschaltkreis, der eingerichtet ist zum Setzen der Referenz-Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  20. Vorrichtung zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, aufweisend: • Referenz-Überprüfungsinformation-Ermittlungs-Schaltkreis, der eingerichtet ist zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks in einem Überprüfungs-Schaltkreis außerhalb des Programms, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Empfangs-Schaltkreis, der eingerichtet ist zum Empfangen von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks von dem Programm in dem Überprüfungsschaltkreis, wobei die Überprüfungsinformation auf der Basisblock-Signatur des jeweiligen Basisblocks basiert, wobei die Basisblock-Signatur zumindest des ersten Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur von mindestens dem zweiten Basisblock, gemäß einer Referenz-Überprüfungsinformation des zweiten Basisblocks, ermittelt wird, der dem jeweiligen Basisblock unmittelbar nachfolgt; • Überprüfungsschaltkreis, der eingerichtet ist zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der empfangenen Überprüfungsinformation und der Referenz-Überprüfungsinformation • Setzschaltkreis, der eingerichtet ist zum Setzen der Referenz-Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  21. Vorrichtung zur Datenverarbeitung zum Erzeugen von Programm-Code zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, wobei das Programm mindestens einen ersten Basisblock und einen zweiten Basisblock aufweist, wobei jeder Basisblock mindestens eine Programm-Anweisung aufweist und mit einer Programm-Sprunganweisung endet, wobei zumindest der zweite Basisblock ein möglicher unmittelbarer Nachfolger des ersten Basisblocks ist, aufweisend: • Referenz-Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Referenz-Überprüfungsinformation des mindestens einen Basisblocks basierend auf einer Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur eine Signatur des jeweiligen Basisblocks aufweist und wobei die Basisblock-Signatur zumindest des ersten Basisblocks basiert auf einer Signaturfunktion, der zumindest einen Programm-Anweisung des ersten Basisblocks und der Basisblock-Signatur zumindest des zweiten Basisblocks; • Überprüfungsinformation-Code-Abschnitt-Erzeugungs-Schaltkreis, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln von Überprüfungsinformation des mindestens einen Basisblocks während der Ausführung des jeweiligen Basisblocks basierend auf der Basisblock-Signatur des jeweiligen Basisblocks, wobei die Basisblock-Signatur des jeweiligen Basisblocks mittels der Signaturfunktion, der mindestens einen Programm-Anweisung des jeweiligen Basisblocks und optional der Basisblock-Signatur von mindestens einem nachfolgenden Basisblock ermittelt wird, der dem jeweiligen Basisblock unmittelbar nachfolgt; • Überprüfungs-Code-Abschnitt-Erzeugungs-Schaltkreis, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Ermitteln, ob bei der Ausführung des Programms ein Fehler aufgetreten ist, basierend auf der ermittelten Überprüfungsinformation und der Referenz-Überprüfungsinformation; • Setz-Code-Abschnitt-Erzeugungs-Schaltkreis, der eingerichtet ist zum Erzeugen eines Programm-Code-Abschnittes zum Setzen der Überprüfungsinformation des zweiten Basisblocks als erwartete Überprüfungsinformation des zweiten Basisblocks.
  22. 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 18 ausführt.
DE102014117971.4A 2014-12-05 2014-12-05 Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code Active DE102014117971B4 (de)

Priority Applications (2)

Application Number Priority Date Filing Date Title
DE102014117971.4A DE102014117971B4 (de) 2014-12-05 2014-12-05 Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code
PCT/EP2015/078677 WO2016087652A1 (de) 2014-12-05 2015-12-04 Verfahren zur datenverarbeitung zum ermitteln, ob bei einer ausführung eines programms ein fehler aufgetreten ist, und datenverarbeitungsanordnungen zum erzeugen von programm-code

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
DE102014117971.4A DE102014117971B4 (de) 2014-12-05 2014-12-05 Verfahren zur Datenverarbeitung zum Ermitteln, ob bei einer Ausführung eines Programms ein Fehler aufgetreten ist, und Datenverarbeitungsanordnungen zum Erzeugen von Programm-Code

Publications (2)

Publication Number Publication Date
DE102014117971A1 DE102014117971A1 (de) 2016-06-09
DE102014117971B4 true DE102014117971B4 (de) 2017-06-01

Family

ID=54979635

Family Applications (1)

Application Number Title Priority Date Filing Date
DE102014117971.4A Active DE102014117971B4 (de) 2014-12-05 2014-12-05 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) DE102014117971B4 (de)
WO (1) WO2016087652A1 (de)

Families Citing this family (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
FR3047585B1 (fr) 2016-02-09 2018-03-09 Stmicroelectronics (Rousset) Sas Procede et dispositif de surveillance de l'execution d'un code programme
EP3373178B1 (de) * 2017-03-08 2024-09-18 Secure-IC SAS Vergleich von ausführungkontextdaten signaturen mit referenzen
CN107766413B (zh) * 2017-09-05 2023-07-07 珠海宇能云企科技有限公司 一种实时数据流聚合查询的实现方法
EP3975017A1 (de) * 2020-09-29 2022-03-30 Siemens Aktiengesellschaft Verfahren zur protokollierung einer vielzahl von ereignissen in einer codierten tracer-variablen in einem sicherheitsgerichteten computerprogramm
CN114625106B (zh) * 2022-03-07 2024-05-14 深圳市元征科技股份有限公司 车辆诊断的方法、装置、电子设备及存储介质
CN116450402B (zh) * 2023-06-15 2023-08-18 北京智芯微电子科技有限公司 程序流监控方法、编译方法、装置、处理器及计算机设备

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7506217B2 (en) * 2005-12-30 2009-03-17 Intel Corporation Apparatus and method for software-based control flow checking for soft error detection to improve microprocessor reliability
DE102010037457B4 (de) * 2010-09-10 2012-06-21 Technische Universität Dresden 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

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
GALLA, T. u.a.: Control Flow Monitoring for a Time-Triggered Communication Controller. 10th European Workshop on Dependable Computing (EWDC-10). Mai 1999 *
SCHÜTTE, M.A. u.a.: Processor Control Flow Monitoring Using Signatured Instruction Streams. Computers, IEEE Transactions on, Vol.C-36, März 1987, S. 264 – 276 *
SOSNOWSKI, J.: Detection of control flow errors using signature and checking instruc-tions. Test Conference, 1988. Proceedings. New Frontiers in Testing, International, September 1988, S. 81 – 88 *

Also Published As

Publication number Publication date
DE102014117971A1 (de) 2016-06-09
WO2016087652A1 (de) 2016-06-09

Similar Documents

Publication Publication Date Title
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
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
DE102011005209B4 (de) Programmanweisungsgesteuerte Instruktionsflusskontrolle
EP2188755A1 (de) Verfahren und vorrichtung zur sicherung eines programms gegen eine kontrollflussmanipulation und gegen einen fehlerhaften programmablauf
DE102011108077A1 (de) Verfahren zur Speicherplatzverwaltung in einem multitaskingfähigen Datenverarbeitungssystem
DE102019122145A1 (de) Gesicherte x-modulare redundanz
DE102011011333B4 (de) Lesen in Peripheriegeräte und schreiben aus Peripheriegeräten mit zeitlich getrennter, redundanter Prozessorausführung
DE102007056218A1 (de) Verfahren zur Behandlung von transienten Fehlern in Echtzeitsystemen, insbesondere in Steuergeräten von Kraftfahrzeugen
DE102011006000B4 (de) Signaturaktualisierung durch Codetransformation
DE102007040721B4 (de) Datenverarbeitungsanordnung, Verfahren zur Datenverarbeitung, Computerprogrammelement und Überprüfungsanordnung für einen Speicher
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
DE102019118703A1 (de) System und Verfahren zum kontinuierlichen Verifizieren der Bauelementzustandsintegrität
DE102005046696B4 (de) Verfahren zum Erzeugen von geschütztem Programmcode und Verfahren zum Ausführen von Programmcode eines geschützten Computerprogramms sowie Computerprogrammprodukt
DE102022109866A1 (de) System für eine verbesserte sicherheits- und schutzprüfung
EP3798873B1 (de) Verfahren zum schützen einer computer-implementierten anwendung vor manipulation
EP4167114A1 (de) Automatische analyse einer ausnutzbarkeit von schwachstellen eines software-images
DE102020211540A1 (de) Verfahren zur Absicherung eines Mikrocontrollers
DE102012010102A1 (de) Verfahren und Vorrichtung zur Datenverarbeitung
DE102010031017A1 (de) Verfahren zur Überwachung des Programmablaufs eines Prozessors
EP4396715A1 (de) Automatische analyse einer ausnutzbarkeit von schwachstellen eines software-images
EP4281890A1 (de) Verfahren zur bestimmung der integrität einer datenverarbeitung, vorrichtung, datenverarbeitungsanlage und anlage
EP3876123A1 (de) Anordnung und betriebsverfahren für einen sicheren hochfahrablauf einer elektronischen einrichtung
DE102014015585A1 (de) Vorrichtung, System und Verfahren zum Schützen von Daten
DE102022208087A1 (de) Verfahren zum Überprüfen einer Verarbeitung von Nutzdaten
WO2021078822A1 (de) Authentifizierung einer teilkonfiguration einer feldprogrammierbaren logikgatter-anordnung

Legal Events

Date Code Title Description
R012 Request for examination validly filed
R016 Response to examination communication
R016 Response to examination communication
R018 Grant decision by examination section/examining division
R020 Patent grant now final
R082 Change of representative
R081 Change of applicant/patentee

Owner name: SILISTRA SYSTEMS GMBH, DE

Free format text: FORMER OWNER: TECHNISCHE UNIVERSITAET DRESDEN, 01069 DRESDEN, DE