DE102016102590B4

DE102016102590B4 - Datenverarbeitungseinrichtungen und verfahren zum rekonstruieren eines puf-werts

Info

Publication number: DE102016102590B4
Application number: DE102016102590.9A
Authority: DE
Inventors: Rainer Göttfert
Original assignee: Infineon Technologies AG
Current assignee: Infineon Technologies AG
Priority date: 2016-02-15
Filing date: 2016-02-15
Publication date: 2018-10-04
Anticipated expiration: 2036-02-16
Also published as: DE102016102590A1; US10469270B2; US20170237573A1

Abstract

Datenverarbeitungseinrichtung aufweisend
Eine PUF-Wert-Quelle, die dazu eingerichtet ist, einen Referenz-PUF-Wert und mehrere nachfolgende PUF-Werte zu liefern, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist;
Eine Ermittlungseinrichtung, die eingerichtet ist, eine Menge von Komponenten zu ermitteln, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist;
Einen Speicher zum Speichern von Hilfsdaten zur Rekonstruktion des Referenz-PUF-Werts; und
Eine PUF-Rekonstruktionseinrichtung, die eingerichtet ist,
den Referenz-PUF-Wert aus den nachfolgenden PUF-Werten ausgehend von der Annahme zu rekonstruieren, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen,
den Referenz-PUF-Wert basierend auf den Hilfsdaten zu rekonstruieren, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren und wobei der Code ein linearer Code ist, und
den Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes zu rekonstruieren.

Description

Ausführungsbeispiele betreffen allgemein Datenverarbeitungseinrichtungen und Verfahren zum Rekonstruieren eines PUF-Werts.
PUFs (Physical Uncloneable Functions) sind für sicherheitsrelevante Anwendungen, wie beispielweise zur Authentifizierung, interessant. Mechanismen zur Generierung von PUF-Werten liefern im Allgemeinen bei mehreren PUF-Generierungen zwar ähnliche, allerdings nicht identische PUF-Werte, was typischerweise je nach Anwendungsfall, z.B. zur Schlüsselgenerierung, jedoch erforderlich ist. Entsprechend sind effiziente Verfahren wünschenswert, die es ermöglichen, einen bei einer zweiten PUF-Generierung erzeugten PUF-Wert derart zu korrigieren, dass er mit dem bei einer ersten PUF-Generierung erzeugten PUF-Wert übereinstimmt.
Aus dem Dokument DE 10 2013 013 047 A1 ist sind eine Vorrichtung und ein Verfahren zur Bestimmung einer Kennung basierend auf einer Vielzahl von Zellen bekannt. Bei dem Verfahren werden die Zellen in Teilmengen unterteilt, wobei für jede der Teilmengen ermittelt wird, ob eine rekonstruierbare Information bestimmbar ist, wobei, falls für eine Teilmenge eine rekonstruierbare Information bestimmbar ist, die rekonstruierbare Information bestimmt und gespeichert wird. Falls für eine Teilmenge eine rekonstruierbare Information nicht bestimmbar ist, eine Fehlerinformation bestimmt und für diese Teilmenge gespeichert wird.
Aus dem Dokument DE 10 2011 079 259 A1 ist eine Bitfehlerkorrektur zur Beseitigung von altersbedingten Fehlern in Bitmustern bekannt.
Gemäß einer Ausführungsform wird eine Datenverarbeitungseinrichtung bereitgestellt mit einer PUF-Wert-Quelle, die dazu eingerichtet ist, einen Referenz-PUF-Wert und mehrere nachfolgende PUF-Werte zu liefern, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist, einer Ermittlungseinrichtung, die eingerichtet ist, eine Menge von Komponenten zu ermitteln, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist, einen Speicher zum Speichern von Hilfsdaten zur Rekonstruktion des Referenz-PUF-Werts; und eine PUF-Rekonstruktionseinrichtung, die eingerichtet ist, den Referenz-PUF-Wert aus den nachfolgenden PUF-Werten ausgehend von der Annahme zu rekonstruieren, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen, den Referenz-PUF-Wert basierend auf den Hilfsdaten zu rekonstruieren, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren und wobei der Code ein linearer Code ist, und den Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes zu rekonstruieren..
Gemäß einer weiteren Ausführungsform wird ein Verfahren zum Rekonstruieren eines PUF-Werts gemäß der oben beschriebenen Datenverarbeitungseinrichtung bereitgestellt.
Die Figuren geben nicht die tatsächlichen Größenverhältnisse wieder, sondern sollen dazu dienen, die Prinzipien der verschiedenen Ausführungsbeispiele zu illustrieren. Im Folgenden werden verschiedene Ausführungsbeispiele mit Bezug auf die folgenden Figuren beschrieben.

1 zeigt eine Chipkarte.
2 zeigt eine Anordnung mit einem kumulativen Fehlerregister und einem Decoder, der als Ergebnis den Fehlervektor ausgibt.
3 zeigt eine Anordnung mit einem kumulativen Fehlerregister und einem Decoder, der als Ergebnis das Codewort ausgibt.
4 zeigt eine Anordnung, die unterschiedliche Betriebsmodi für die PUF-Rekonstruktion ermöglicht.
5 zeigt eine Datenverarbeitungseinrichtung gemäß einer Ausführungsform.
6 zeigt ein Ablaufdiagramm, dass ein Verfahren zum Rekonstruieren eines PUF-Werts veranschaulicht.

Die folgende detaillierte Beschreibung bezieht sich auf die beiliegenden Figuren, die Details und Ausführungsbeispiele zeigen. Diese Ausführungsbeispiele sind so detailliert beschrieben, dass der Fachmann die Erfindung ausführen kann. Andere Ausführungsformen sind auch möglich und die Ausführungsbeispiele können in struktureller, logischer und elektrischer Hinsicht geändert werden, ohne vom Gegenstand der Erfindung abzuweichen. Die verschiedenen Ausführungsbeispiele schließen sich nicht notwendig gegenseitig aus sondern es können verschiedene Ausführungsformen miteinander kombiniert werden, so dass neue Ausführungsformen entstehen. Im Rahmen dieser Beschreibung werden die Begriffe „verbunden“, „angeschlossen“ sowie „gekoppelt“ verwendet zum Beschreiben sowohl einer direkten als auch einer indirekten Verbindung, eines direkten oder indirekten Anschlusses sowie einer direkten oder indirekten Kopplung.
Die Abkürzung PUF steht für „Physical unclonable function“ oder Physikalische Hashfunktion. Die Idee dabei ist, physikalische Eigenschaften eines Objektes zu digitalisieren und so eine dem Objekt zugeordnete Bitfolge (Nummer) zu erhalten. Dabei ist es wünschenswert, dass die Bitfolgen zweier verschiedener physikalischer Objekte zueinander unkorreliert sind. Ein einfaches Beispiel zur Veranschaulichung ist ein Blatt Papier. Unter einem Mikroskop betrachtet erkennt man eine spezielle Feinstruktur der Holzspäne oder Zellstoffteile. Die Struktur kann mit Hilfe eines geeigneten Verfahrens vermessen werden und das Ergebnis als Bitfolge dargestellt werden. Diese Bitfolge ist die PUF oder der PUF-Wert für das Blatt. Ein anderes Blatt Papier ergibt bei diesem Vorgehen im Allgemeinen eine Bitfolge, die unkorreliert ist zur Bitfolge des ersten Blatts.
Der Prozess der Erzeugung einer Bitfolge (des PUF-Werts) aus den Eigenschaften des physikalischen Objektes wird als PUF-Generierung bezeichnet. Es ist wünschenswert, dass die PUF-Generierung auf effiziente Weise möglich ist.
Eine wünschenswerte Eigenschaft eines PUF-Generierungs-Mechanismus ist, dass dasselbe physikalische Objekt bei jeder PUF-Generierung jedes Mal dieselbe Bitfolge ergibt (z.B. bei jeder PUF-Anforderung). Dies ist jedoch typischerweise nicht der Fall. Eine wiederholte PUF-Generierung für dasselbe physikalische Objekt liefert typischerweise Bitfolgen, die zwar untereinander sehr ähnlich, aber im Allgemeinen nicht miteinander identisch sind. Dieses Defizit kann mit Methoden der Codierungstheorie (Fehlerkorrektur) ausgeglichen werden.
Sei P ein ursprünglicher PUF-Wert, der einem physikalischen Objekt zugeordnet wird. Der PUF-Wert wird im Zuge des Herstellungsprozesses für das physikalische Objekt ein für alle Mal bestimmt. P wird im Folgenden der wahre PUF-Wert genannt, der dem Objekt zugeordnet ist. Die Bestimmung des wahren PUF-Werts P erfolgt beispielsweise in der Fabrik, in der das physikalische Objekt, z.B. als eine Komponente einer Chipkarte, hergestellt wird, durch Messung bestimmter sensibler Parameter. Die Werte der gemessenen Parameter hängen von zufälligen strukturellen Eigenschaften des Objekts ab, die außerhalb der Kontrolle des Herstellers liegen. Unterschiedlichen Objekten entsprechen im Allgemeinen unterschiedliche, zueinander unkorrelierte PUF-Werte.
Der PUF-Wert P ist eine Folge von Nullen und Einsen und kann daher als binärer Vektor dargestellt werden.
Man kann sich den PUF-Wert P als eine Art Fingerabdruck des physikalischen Objekts vorstellen. Durch den wahren PUF-Wert P kann das physikalische Objekt eindeutig identifiziert werden. Das physikalische Objekt ist beispielsweise Bestandteil einer Chipkarte.
1 zeigt eine Chipkarte 100.
Die Chipkarte 100 weist einen Träger 101 und ein Chipkartenmodul 102 auf. Das Chipkartenmodul 102 hat verschiedene Komponenten wie beispielsweise einen nichtflüchtigen Speicher 103 und eine CPU (Central Processing Unit) 104. Insbesondere weist die Chipkarte eine Komponente 105 auf, die als PUF-Quelle dient, beispielsweise einen Speicher (z.B. mit einer Vielzahl von SRAM-Zellen), dessen zufälliger Anfangszustand als PUF-Wert verwendet wird.
Der PUF-Wert P kann als eine Identifikationsnummer für die Chipkarte 100 (genauer für das Chipkartenmodul 102 in der Chipkarte 100) angesehen werden. Beispielsweise weist das Chipkartenmodul 102 einen Kryptoprozessor auf, der aus dieser Identifikationsnummer einen chipkartenindividuellen kryptographischen Schlüssel ableitet oder die CPU 104 leitet selbst einen kryptographischen Schlüssel daraus ab.
Aus Sicherheitsgründen wird weder der wahre PUF-Wert P noch der aus ihm abgeleitete kryptographische Schlüssel auf der Chipkarte 100 gespeichert. Stattdessen befindet sich auf der Chipkarte 100 ein sogenanntes PUF-Modul 106, welches mit dem physikalischen Objekt 105 verbunden ist. Wird der PUF-Wert P benötigt, dann wird ein sogenannter PUF-Request (PUF-Anforderung) gestellt, worauf das PUF-Modul 106 den PUF-Wert jedes Mal neu bestimmt (durch interne Messung). Mit anderen Worten antwortet das PUF-Modul 106 auf einen PUF-Request mit der Ausgabe eines PUF-Wertes P'. P' wird im Folgenden als der aktuelle PUF-Wert bezeichnet.
Aufgrund von Umwelteinflüssen, Alterungsprozessen und Messfehlern wird der aktuelle PUF-Wert P' nicht unbedingt zu dem wahren PUF-Wert P identisch sein. Typischerweise werden P und P' sich in einigen Komponenten unterscheiden. Ziel ist aber auf jeden Fall, den wahren PUF-Wert P zu bestimmen - aus dem aktuellen, zur Verfügung stehenden, PUF-Wert P'. Dies wird als PUF-Wert-Rekonstruktion bezeichnet, die beispielsweise von einem PUF-Wert-Rekonstruktionsmodul 107, das auch zumindest teilweise durch die CPU 104 realisiert sein kann, durchgeführt wird.
Dazu wird, beispielsweise schon bei der Herstellung, zu dem dabei bestimmten wahren PUF-Wert P eine Hilfsgröße H berechnet. Die Hilfsgröße H ist ebenfalls eine 0-1-Sequenz (d.h. ein binärer Vektor). Informationstheoretisch gesprochen enthält H einen Teil von P aber nicht ganz P. Daher ist es unmöglich aus H allein P zu bestimmen. Die Hilfsgröße H wird im nichtflüchtigen Speicher 103 der Chipkarte 100 gespeichert. Bringt man den aktuellen PUF-Wert P' und H zusammen, so kann aus diesen beiden Größen der wahre PUF-Wert P berechnet werden (vorausgesetzt, dass P' sich nicht zu sehr von P unterscheidet).
Die PUF-Wert-Rekonstruktion - also die Bestimmung von P aus P' und H - kann mit Hilfe fehlerkorrigierender Codes erfolgen. Angenommen, der PUF-Wert P ist n Bit lang, dann kann ein binärer Code C der Länge n verwendet werden. Dabei ist C eine Menge von Codewörtern, und jedes Codewort von C ist ein n Bit langer Zeilenvektor.
Die Hilfsgröße H wird wie folgt gebildet.
Sei P der wahre PUF-Wert. Dann ist die zugehörige Hilfsgröße H gegeben durch $H=P+c,$
wobei c = c_rand ein zufälliges aus C gezogenes Codewort ist. (Das „+“ steht für bitweise Addition modulo 2).
Die Hilfsgröße H, der wahre PUF-Wert P und das zufällig gewählte Codeword c sind binäre Zeilenvektoren gleicher Länge. H wird im Folgenden auch als Hilfsvektor bezeichnet.
Damit kann wie folgt eine PUF-Wert-Rekonstruktion durchgeführt werden.
Gegeben seien der aktuelle PUF-Wert P' und der Hilfsvektor H. Die binären Vektoren P' und H werden komponentenweise addiert. Das ergibt $P'+H=P'+ (P+c) = (P'+P) + c=e+c=y .$
Das heißt, dass die Summe y = P' + H als ein (potentiell) fehlerhaftes Codewort aufgefasst werden kann.
Der Vektor c ist das fehlerfreie Codewort. Der Vektor e = P' + P ist der Fehlervektor.
Der Vektor y ist tatsächlich verfügbar, da y die Vektorsumme aus dem aktuellen (zur Verfügung stehenden) PUF-Wert P' und dem im Speicher 103 bereitgehaltenen Hilfsvektor H ist. Mithilfe eines Decoders (z.B. des PUF-Wert-Rekonstruktionsmoduls 107) wird aus y das Codewort c, oder, was äquivalent dazu ist, der Fehlervektor e berechnet.
Aus dem Codewort c und dem Hilfsvektor H kann sodann der wahre PUF-Wert P berechnet werden: Aus H = P + c folgt sofort, dass $P=H+c .$
Damit ist die Rekonstruktion des wahren PUF-Werts P abgeschlossen.
Allerdings funktioniert diese Herangehensweise nur dann, wenn nicht zu viele Fehler aufgetreten sind, d.h. wenn der Fehlervektor e nicht zu viele Einsen enthält, oder - was damit gleichbedeutend ist - wenn sich der wahre PUF-Wert P und der aktuelle PUF-Wert P' nicht zu stark voneinander unterscheiden.
Im Folgenden werden Ausführungsbeispiele beschrieben, die eine PUF-Rekonstruktion auch bei einer höheren Anzahl von Fehler (als von dem verwendeten Code korrigierbar sind), ermöglichen.
In der Kodierungstheorie wird im Allgemeinen angenommen, dass Übertragungsfehler in den einzelnen Komponenten voneinander unabhängig und überall mit derselben Wahrscheinlichkeit auftreten. (Das verwendete Modell ist dann typischerweise das eines sogenannten „binären symmetrischen Kanals“.) Übertragen auf die PUF-Rekonstruktion bedeutet das, dass jede Komponente von P' mit genau derselben Wahrscheinlichkeit abweicht von der entsprechenden Komponente von P. Wenn beispielsweise für eine PUF sich im Durchschnitt der aktuelle PUF-Wert P' und der wahre PUF-Wert P in 10% der Komponenten unterscheiden, würde man annehmen, dass eine beliebige ins Auge gefasste Komponente bei jeder neuen PUF-Generierung mit der Wahrscheinlichkeit p = 0,1 fehlerhaft ist.
Für zahlreiche PUFs trifft dies aber nicht zu. Die einzelnen Komponenten weisen unterschiedliche Fehlerraten auf. Dabei ist zu beachten, dass Komponenten mit hohen Fehlerraten bereits bei der Herstellung, z.B. in der Fabrik, identifiziert und ausgemustert werden können und von diesen Komponenten kein Gebrauch gemacht wird. Sie können also für ungültig erklärt und ignoriert werden. Für eine PUF mit durchschnittlich 10% Fehlern ist es also durchaus möglich, dass eine Komponente von P' mit der Wahrscheinlichkeit p = 0.05 und eine andere Komponente mit der Wahrscheinlichkeit p = 0.15 von der entsprechenden Komponente in P abweicht.
Es kann sogar Komponentenpositionen geben, an denen so gut wie nie ein Fehler auftritt. Solche PUF- Komponenten werden als quasistabil bezeichnet.
Gemäß verschiedenen Ausführungsformen werden

a) die Positionen quasistabiler PUF-Komponenten bestimmt und
b) diese Information für die PUF-Wert-Rekonstruktion nutzbar gemacht.

Selbst wenn nur relativ wenige der PUF-Komponenten quasistabil sind, kann diese Tatsache für die PUF-Wert-Rekonstruktion ausgenutzt werden und es können auf diese Weise wesentlich mehr Fehler korrigiert werden als es unter Einsatz eines Decoders (der im Rahmen der gemäß dem verwendeten Code korrigierbaren Fehler arbeitet) möglich wäre.
Zur Illustration wird als Beispiel eine PUF der Länge n = 32 betrachtet. Der verwendete fehlerkorrigierende Code sei der (32, 6, 16) Reed-Muller Code. In diesem Code haben die Codewörter die Länge 32. Es gibt 2⁶ = 64 verschiedene Codewörter. Der Code hat die Minimumdistanz d = 16. Das bedeutet, dass sich zwei verschiedene Codewörter in mindestens 16 ihrer Komponenten unterscheiden. Daraus ergibt sich eine Fehlerkorrekturkapazität von bis zu 7 Bitfehlern (pro 32-Bit-Wort).
Wird dieser Code unter Einsatz eines Decoders für die PUF-Wert-Rekonstruktion benutzt, dann wird die PUF-Wert-Rekonstruktion dann (und nur dann) gelingen, wenn der (32 Bit lange) aktuelle PUF-Wert P' sich von dem (ebenfalls 32 Bit langen) wahren PUF-Wert P in höchstens 7 Komponenten unterscheidet.
Es sei nun angenommen, dass es sechs geeignete quasistabile PUF-Komponenten in P gibt und ihre Positionen identifiziert wurden. Geeignet bedeutet dabei, dass die sechs zugehörigen Spaltenvektoren der Generatormatrix des Codes linear unabhängig sind.
Dann können dem aktuellen PUF-Wert P' die entsprechenden sechs Komponenten entnommen werden und es handelt sich bei ihnen gleichzeitig um sechs Komponenten des gesuchten wahren PUF-Werts P. Somit sind sechs Komponenten des 32 Bit langen wahren PUF-Werts P bekannt.
Mithilfe dieser sechs bekannten Komponenten von P und dem zur Verfügung stehenden Hilfsvektor H lassen sich die restlichen 26 Komponenten von P berechnen. Das heißt, dass selbst dann, wenn der aktuelle PUF-Wert P' sich von dem wahren PUF-Wert P in j Komponenten unterscheidet, wobei j eine beliebige Zahl zwischen 0 und 26 sein kann, die einwandfreie Rekonstruktion des wahren PUF-Werts P gelingt. Insbesondere können statt nur sieben Bitfehlern auf diese Weise bis zu 26 Bitfehler korrigiert werden (in dem 32 Bit langen PUF-Segment).
Zur Ermittlung quasistabiler Komponenten kann ein so genanntes kumulatives Fehlerregister verwendet werden, dass im Folgenden genauer beschrieben wird.
Wie oben beschrieben sind für die PUF-Wert-Rekonstruktion a) der aktuelle PUF-Wert P' und b) der Hilfsvektor H gegeben und der wahre PUF-Wert P ist gesucht.
Für den Hilfsvektor H gilt: $H=P+c,$
wobei c ein zufällig gewähltes Codewort ist. Addition von P' zu beiden Seiten der Gleichung ergibt $P'+H= (P'+P) + c .$
Der Vektor e = P'+P heißt Fehlervektor, eine Bezeichnung die im doppelten Sinn zutreffend ist:

Einerseits beschreibt der Vektor e die Differenz zwischen dem wahren PUF-Wert P und dem aktuellen PUF-Wert P', also sozusagen den Fehler, der bei der aktuellen PUF-Wert-Generierung passiert ist.

Andererseits ist y = P'+H = e+c und der Vektor y kann somit als eine fehlerhafte Version des Codeworts c aufgefasst werden. Die Situation ist analog zu der Übertragung einer Nachricht über einen störanfälligen Kanal: Das Codewort c wird gesendet. Im Kanal tritt der Übertragungsfehler e auf, und das Nachrichtenwort y wird empfangen.
Bei der PUF-Rekonstruktion verfügt man über den Vektor y = P'+H, da die Vektoren P' und H bekannt sind.
Um nun die Vektoren e oder c zu berechnen, kann der Vektor y einem Decoder (gemäß dem verwendeten Code) zugeführt werden. Sofern nicht zu viele Bitfehler aufgetreten sind, produziert der Decoder als Output entweder direkt das Codewort c oder den Fehlervektor e, was vom Typ des verwendeten Decoders abhängt.
Angenommen der Decoder liefert c, dann lässt sich der wahre PUF-Wert P durch P = H+c berechnen. Der Fehlervektor e lässt sich durch e = P'+P berechnen.
Angenommen der Decoder liefert e, dann lässt sich der wahrer PUF-Wert P durch P = P'+e berechnen. Sollte auch das Codewort c von Interesse sein, so lässt sich dieses aus der Gleichung H = P+c berechnen: c = P+H.
Seien nun P₀, P₁, P₂, ... die vom PUF-Modul 106 zu den Zeiten t = 0,1,2, ... ausgegebenen aktuellen PUF-Werte. Die Vektoren $\begin{matrix} y_{0} = {H+P}_{0}, & y_{1} = {H+P}_{1}, & y_{2} = {H+P}_{2}, & \dots \end{matrix}$
werden mit der Hilfe eines Decoders dekodiert. Seien e₀, e₁, e₂, ... die dabei anfallenden Fehlervektoren.
Das kumulative Fehlerregister ist ein Register der Länge n, d.h. der Länge des PUF-Werts P. Das Register wird mit lauter Nullen („Alles Null“) initialisiert.
Sei R_t der Inhalt des Registers zum Zeitpunkt t. Dann ist der Inhalt des Registers zum Zeitpunkt t+1 gegeben durch $R_{(t+1)} = R_{t} {ODER e}_{t},$
wobei die Verknüpfung „ODER“ die Komponentenweise logische Oder-Verknüpfung zweier binärer Vektoren darstellt, d.h., $0 ODER 0=0$
$0 ODER 1=1$
$1 ODER 0=1$
$1 ODER 1=1$
also z.B. (1,0,0,1) ODER (0,0,1,0) = (1,0,1,1).
Beispiel: Sei n = 10. Die ersten fünf Fehlervektoren seien gegeben durch $e_{0} = 10000 00000$
$e_{1} = 01000 00000$
$e_{2} = 1100010000$
$e_{3} = 01000 10000$
$e_{4} = 10010 00000$
In diesem Fall sind die Inhalte des kumulativen Fehlerregisters zu den Zeitpunkten t = 0, 1, 2, 3, 4, 5 gegeben durch $R0=00000 00000$
$R1=10000 00000=e1$
$R2=11000 00000$
$R3=11000 10000$
$R4=11000 10000$
$R5=11010 10000$
Das kumulative Fehlerregister lässt sich beispielsweise als Komponente des PUF-Rekonstruktionsmoduls 107 implementieren, z.B. in Hardware.
2 zeigt eine Anordnung 200 mit einem kumulativen Fehlerregister 201 und einem Decoder 202, der den Fehlervektor e ausgibt.
Die Anordnung 200 ist beispielsweise Teil des PUF-Wert-Rekonstruktionsmoduls 107.
Ein erster Addierer 203 addiert die Hilfsdaten H (die z.B. im Speicher 103 gespeichert sind) zu dem aktuellen PUF-Wert P_t und liefert das Resultat y_t an den Decoder 202. Der Decoder 202 ermittelt den zugehörigen Fehlervektor e_t, den ein zweiter Addierer 204 zu dem aktuellen PUF-Wert P_t addiert, so dass der wahre PUF-Wert rekonstruiert wird.
Addierer werden im Folgenden als Einheiten verstanden, die eine komponentenweise XOR-Verknüpfung ihrer Eingangsvektoren durchführen.
Außerdem wird der Fehlervektor e_t einer ODER-Einheit 205 zugeführt, die den bisherigen Inhalt des kumulativen Fehlerregisters R_t mit dem Fehlervektor e_t komponentenweise verodert (d.h. ODER-verknüpft) und das Ergebnis R_t+1 im kumulativen Fehlerregister 201 speichert.
3 zeigt eine Anordnung 300 mit einem kumulativen Fehlerregister 301 und einem Decoder 302, der das Codewort c ausgibt.
Die Anordnung 300 ist beispielsweise Teil des PUF-Wert-Rekonstruktionsmoduls 107.
Ein erster Addierer 303 addiert die Hilfsdaten H (die z.B. im Speicher 103 gespeichert sind) zu dem aktuellen PUF-Wert P_t und liefert das Resultat y_t an den Decoder 302. Der Decoder 302 ermittelt das zugehörige Codewort c, das ein zweiter Addierer 304 zu den Hilfsdaten H addiert, so dass der wahre PUF-Wert rekonstruiert wird.
Ein dritter Addierer 305 addiert den rekonstruierten PUF-Wert zu dem aktuellen PUF-Wert P_t, so dass der zugehörige Fehlervektor e_t erzeugt wird.
Der Fehlervektor e_t wird einer ODER-Einheit 306 zugeführt, die den bisherigen Inhalt des kumulativen Fehlerregisters R_t mit dem Fehlervektor e_t komponentenweise verodert und das Ergebnis R_t+1 im kumulativen Fehlerregister 301 speichert.
Für eine konkrete Zelle des kumulativen Fehlerregisters zum Zeitpunkt t = N bedeutet es, wenn sie den Wert 1 enthält, dass im Verlauf der ersten N PUF-Wert-Generierungen in der entsprechenden PUF-Komponente mindestens einmal (und bis zu N mal) ein Fehler auftrat. Wenn die Zelle den Wert 0 enthält, bedeutet das, dass bisher in der entsprechenden PUF-Komponente kein Fehler aufgetreten ist.
Beispiel: In einer PUF der Länge n = 32 seien die Komponenten Nummer 5, 9, 17 und 26 quasistabil. Diese Komponenten seien bei jeder neuen PUF-Wert-Generierung mit der Wahrscheinlichkeit p = 0,0001 fehlerhaft. Die Fehlerwahrscheinlichkeiten für alle anderen Komponenten liegen zwischen p = 0.01 und p = 0.15. Es wird nun N-mal ein PUF-Wert generiert. Bei jeder (erfolgreichen) PUF-Wert-Rekonstruktion fällt ein Fehlervektor e an, der in das kumulative Fehlerregister eingeht. Für N = 1000 wird das kumulative Fehlerregister dann mit hoher Wahrscheinlichkeit in den Zellen 5, 9, 17 und 26 eine Null stehen haben und in den restlichen 28 Zellen eine Eins. Daher kann man aus dem kumulativen Fehlerregister zum Zeitpunkt t = 1000 die Positionen der vier quasistabilen PUF-Komponenten auslesen.
Im Folgenden wird nun die Berechnung eines Codeworts aus einigen seiner Komponenten erläutert.
Es wird ein binärer (n, M, d) Code C betrachtet. Der Code hat die Länge n, was bedeutet, dass jedes Codewort ein binärer Vektor mit n Komponenten ist. Die Menge C enthält insgesamt M Codewörter. Der Code hat die Minimumdistanz d. Das bedeutet, dass sich zwei unterschiedliche Codewörter in mindestens d Komponenten voneinander unterscheiden. Mit einem Code der Minimumdistanz d können alle q-Bitfehler korrigiert werden, für 1 <= q < d/2.
Die Komponenten eines Codeworts sind redundant. Dadurch eröffnet sich die Möglichkeit zur Fehlerkorrektur.
Die typische Situation in der Kodierungstheorie ist die folgende: Ein Codewort c = (c₁, c₂, ... , c_n) wird gesendet und ein Nachrichtenvektor y = (y₁, y₂, ..., y_n) wird empfangen. Aufgrund von Übertragungsfehlern können sich für gewisse Positionen i die Komponenten y_i und c_i voneinander unterscheiden. Es wird jede Komponente von y als potentiell fehlerhaft angenommen. Mit der Hilfe eines Decoders werden die Positionen der tatsächlich fehlerhaften Komponenten ermittelt. Dies gelingt, wenn ihre Gesamtanzahl kleiner als d/2 ist. Kennt man die Positionen der fehlerhaften Komponenten, dann ersetzt man diese Komponenten durch ihr binäres Komplement - und erhält so aus y das Codewort c.
Wenn bekannt ist, dass in bestimmten Komponenten des empfangenen Nachrichtenvektors y mit Sicherheit kein Fehler aufgetreten ist - diese Komponenten y_j somit mit den Codewort-Komponenten c_j übereinstimmen - dann ermöglicht die Redundanz der Codewort-Komponenten einen zweiten, völlig anderen, Zugang zur Rekonstruktion des gesendeten Codeworts c aus y, der im Folgenden beschrieben wird.
Definition:
Sei C ein binärer Code der Länge n. Sei J = {j₁ ... , j_r} eine Indexmenge. D.h., die Menge J ist eine Teilmenge der Menge {1, ..., n}. Die Indexmenge J heißt codewortbestimmend, wenn es für jeden binären Vektor b = (b₁, ..., b_r) höchstens ein Codewort c = (c₁, ..., c_n) in C gibt mit c_(j
1) = b₁, .. , c_(j
r) = b_r.
Es stellt sich die Frage, wie viele Komponenten eines Codeworts bekannt sein müssen, um aus ihnen das gesamte Codewort berechnen zu können. Darüber geben die folgenden Sätze Auskunft.
Satz 1:
Sei C ein binärer (n, M, d) Code. Jede Indexmenge J = {j₁, ... , j_r} mit $r < log M$
ist nicht codewortbestimmend, wobei log(.) den Logarithmus zur Basis 2 bezeichnet.
Das heißt, dass weniger als log M Komponenten eines Codeworts nicht ausreichen, um das Codewort eindeutig zu rekonstruieren.
Satz 2:
Sei C ein binärer (n, M, d) Code. Jede Indexmenge J = {j₁, ... , j_r} mit $r > = n-d+1$
ist codewortbestimmend.
Das heißt, dass n - d + 1 Komponenten auf jeden Fall ausreichen, um das Codewort zu berechnen.
Satz 3:
Sei C ein binärer (n, M, d) Code, und sei J = {j₁, ... , j_r} codewortbestimmend und jede echte Teilmenge von J sei nicht codewortbestimmend. Dann gilt $log M < = r < = n-d+1 .$
Beispiel:
Für einen binären (32, 64, 16) Code (linear oder nichtlinear) ist n - d + 1 = 17 und log M = 6. Beliebige 17 Komponenten des 32 Bit langen Codeworts bestimmen das Codewort eindeutig. Manchmal genügen aber auch schon 6 Komponenten.
Ein binärer (n, M, d) Code C heißt linear, wenn C ein Vektorraum ist über dem Grundkörper F₂ = {0,1}. Die Dimension des linearen Codes C ist die Dimension des Vektorraums C. Ein linearer Code der Dimension k enthält daher 2^k Codewörter. Das heißt: M = 2^k.
Für einen linearen Code der Länge n, der Dimension k und der Minimumdistanz d ist die Bezeichnung (n, k, d) Code üblich (anstelle der allgemeineren Bezeichnung (n, 2^k, d) Code).
Ein binärer linearer (n, k, d) Code ist eindeutig definiert durch eine binäre k x n Matrix G vom Rang k, der sogenannten Generatormatrix.
Bei einem linearen (n, k, d) Code wird ein k Bit langer Nachrichtenvektor v zu einem n Bit langen Codewort c erweitert. Man sagt „v wird in c kodiert“. Die Kodierung wird mittels der Generatormatrix bewerkstelligt: $v G=c .$
Die 2^k möglichen Nachrichtenvektoren v und die 2^k Codewörter des Codes stehen zueinander in bijektiver Korrespondenz: Ein beliebiger k Bit langer Nachrichtenvektor v bestimmt eindeutig das zugehörige n Bit lange Codewort und umgekehrt gehört zu jedem n Bit langen Codewort ein eindeutig bestimmter k Bit langer Nachrichtenvektor v.
Satz 4:
Sei C ein linearer (n, k, d) Code mit Generatormatrix $G= (G_{1},..., G_{n})$
und sei J = {j₁, ..., j_r} eine Teilmenge von {1, ..., n}. Die Indexmenge J ist codewortbestimmend genau dann, wenn sich unter den r Spaltenvektoren G_(j
1) , ... , G_(j
r) der Generatormatrix k linear unabhängige Vektoren befinden.
Im Folgenden wird ein Algorithmus zur Rekonstruktion eines Codeworts aus bekannten Codewort-Komponenten beschrieben, d.h. eine Vorschrift, wie aus einer codewortbestimmenden Indexmenge J und dem zugehörigen Stützvektor b das Codewort c berechnet werden kann.
Sei J = {j₁, ..., j_r} die codewortbestimmende Indexmenge und b = (b₁, ... ,b_r) der zugehörige Stützvektor. Das heißt, für das zu bestimmende Codewort c = (c₁, ...,c_n) gilt c_(j
1) = b₁,..., c_(j
r) = b_r.
Sei G = (G₁, ..., G_n) die Generatormatrix des zugrundeliegenden linearen (n, k, d) Codes. Unter den r Spaltenvektoren $G_{(j_{1})},..., G_{(j_{r})} .$
befinden sich nach Satz 4 k linear unabhängige Vektoren. Es werden k solche linear unabhängige Vektoren ausgewählt (falls es mehrere Möglichkeiten gibt, das zu tun, dann entscheidet man sich für eine dieser Möglichkeiten).
Die ausgewählten k linear unabhängigen Vektoren werden mit L₁, ..., L_k bezeichnet.
Das heißt, dass {L₁, ..., L_k} eine linear unabhängige Teilmenge von {G_(j
1), ..., G_(j
r)} ist.
Da die Vektoren L₁, ... ,L_k linear unabhängig sind, ist die k x k Matrix $M= (L_{1},..., L_{k})$
invertierbar. Sei M^-1 die inverse Matrix zu M. Das heißt, MM^-1 = I, wobei I die k × k - Einheitsmatrix ist.
Aus dem r Bit langen Stützvektor b = (b₁, ..., b_r) wird ein k-Bit langer Vektor b' = (b₁', ..., b_k') extrahiert.
Der Vektor b' ist ein Teilvektor des Vektors b. Der Vektor b' entsteht aus dem Vektor b, indem r-k Komponenten von b gestrichen werden. Die Komponente b_i wird genau dann aus dem Vektor b entfernt, wenn der Spaltenvektor G_(j
i) nicht in der Menge {L₁, ..., L_k} enthalten ist. Dabei ist zu beachten, dass b' ein Teilvektor von b ist, und b ein Teilvektor von c = (c₁, ... ,c_n) ist.
Nach Konstruktion von b' und der Matrix M gilt: c_j ist eine Komponente von b' genau dann, wenn G_j eine Spalte der Matrix M ist. Es gilt $vG=c .$
für einen eindeutig bestimmten Nachrichtenvektor v der Länge k. Aus dieser Gleichung folgt $vM=b' .$
Multiplizieren beider Seiten der Gleichung von rechts mit der inversen Matrix M^-1 ergibt ${v=b'M}^{- 1} .$
Multiplizieren beider Seiten dieser Gleichung von rechts mit der Generatormatrix G ergibt ${c=vG=b'M}^{- 1} G .$
Zusammenfassend gilt
Satz 5 (Algorithmus zur Codewortrekonstruktion):
Gegeben sei ein linearer (n, k, d) Code C mit Generatormatrix G = (G₁, ..., G_n).
Eingabe: Codewortbestimmende Indexmenge J = {j₁, ..., j_r}, $Stützvektor b= (b_{1},..., b_{r}) .$
Ausgabe: Codewort c = (c₁, ..., c_n).

1) Wähle k linear unabhängige Vektoren unter den Vektoren G_(j
1), ..., G_(j
r) aus und bilde aus ihnen eine invertierbare Matrix M (so dass die ausgewählten Vektoren die Spalten der Matrix M darstellen).
2) Berechne die inverse Matrix M^-1.
3) Bestimme den k Bit langen Teilvektor b' von b in Abhängigkeit von den in 1) selektierten k linear unabhängigen Spaltenvektoren der Generatormatrix G.
4) Berechne c = b' M^-1 G.

c = (c₁, ..., c_n) ist dann das eindeutig bestimmte Codewort aus dem Code C mit der Eigenschaft C_(j
i) = b_i für i = 1, ..., r.
Im Folgenden wird die PUF-Wert- Rekonstruktion auf der Basis quasistabiler PUF-Komponenten beschrieben.
Gegeben sei wieder ein binärer linearer (n, k, d) Code C mit Generatormatrix $G= (G_{1},..., G_{n}) .$
Wie oben bezeichnet P den wahren PUF-Wert und P' den aktuellen PUF-Wert.
Die Indexmenge J = {j₁, ... , j_r} wird dem kumulativen Fehlerregister entnommen.
Aufgrund der dem kumulativen Fehlerregisters entnommenen Indexmenge J wird davon ausgegangen, dass die Komponenten der Vektoren P und P' an den Stellen j₁, ..., j_r miteinander übereinstimmen.
Der Hilfsvektor H (ein Vektor, der wie die Vektoren P und P' ebenfalls die Länge n hat) steht zur PUF-Rekonstruktion zur Verfügung (z.B. aus dem Speicher 103). Es gilt $H=P+c,$
wobei c ein zufällig gewähltes Codewort ist (gewählt aus dem zugrundeliegenden Code C).
Das Ziel ist es, dieses unbekannte Codewort c zu berechnen. Daraus ergibt sich dann sofort der wahre PUF-Wert P = H + c.
Addieren von P' zu beiden Seiten der obigen Gleichung liefert $P'+H= (P'+P) + c .$
Der Vektor y = P' + H = (y₁, ..., y_n) lässt sich berechnen, da die Vektoren P' und H zur Verfügung stehen.
Da die Komponenten der Vektoren P und P' an den Stellen j₁, ..., j_r übereinstimmen, hat der Fehlervektor e = P'+P an diesen Stellen eine Null. Es gilt also $c_{(j_{1})} = y_{(j_{1})},..., c_{(j_{r})} = y_{(j_{r})} .$
Mit anderen Worten: Der Vektor b = (y_(j
1), ..., y_(j
r)) ist ein Stützvektor für das gesuchte Codewort c.
Wenn die Indexmenge J codewortbestimmend ist, dann kann Satz 5 angewendet werden, um das Codewort c zu berechnen. Aus c ergeben sich sodann der wahre PUF-Wert P (via P = H+c), und der Fehlervektor e (via e = P+P'). Der Fehlervektor e kann zur Aktualisierung des kumulativen Fehlerregisters verwendet werden.
Zusammenfassend gilt:
Satz 6 (Algorithmus zur PUF-Wert-Rekonstruktion):
Sei J = {j₁, ..., j_r} eine codewortbestimmende Indexmenge.
Eingabe: P', H, J
Ausgabe: c, P, e

1) Berechne y = P'+H = (y₁, ..., y_n).
2) Berechne den Stützvektor b = (y_(j
1),..., y_(j
r)).
3) Berechne mit dem in Satz 5 beschriebenen Algorithmus das eindeutig bestimmte Codewort c zu dem Stützvektor b, d.h. das Codewort c = (c₁, ... , c_n) mit c_(j
i) = y_(j
i) für i = 1,...,r.
4) Berechne P = c+H.
5) Berechne e = P'+P.
6) (optional): Aktualisiere das kumulative Fehlerregister mit e.

Sollte die dem kumulativen Fehlerregister entnommene Indexmenge J = {j₁, ..., j_r} nicht codewortbestimmend sein (d.h., unter den r Spaltenvektoren G_(j
1) ,..., G_(j
r) der Generatormatrix G befinden sich keine k linear unabhängigen Vektoren) dann kann die Indexmenge J dennoch für die PUF-Wert-Rekonstruktion genutzt werden, nämlich dann, wenn die Anzahl der linear unabhängigen Spaltenvektoren nur geringfügig kleiner als k ist, z.B. k-1, oder k-2. (siehe das unten stehende Beispiel 3 zur PUF-Rekonstruktion).
Beispiel 1 zur PUF-Rekonstruktion:
Die PUF habe die Länge n = 8.
Aktueller PUF-Wert: P' = 0111 0101.
Hilfsvektor: H = 1000 1110.
Zustand des kumulativen Fehlerregisters: R = 1011 0010.
Daher ist J = {2, 5, 6, 8}.
Der zugrundeliegende Code sei der (8, 4, 4) Reed-Muller Code mit der Generatormatrix $G= \begin{matrix} 1111 & 1111 \\ 0000 & 1111 \\ 0011 & 0011 \\ 0101 & 0101 \end{matrix}$
Die Spaltenvektoren $\begin{matrix} G_{2} = \begin{matrix} 1 \\ 1 \\ 0 \\ 0 \end{matrix} & G_{5} = \begin{matrix} 1 \\ 1 \\ 0 \\ 0 \end{matrix} & G_{6} = \begin{matrix} 1 \\ 1 \\ 0 \\ 1 \end{matrix} & G_{(8)} = \begin{matrix} 1 \\ 1 \\ 1 \\ 1 \end{matrix} \end{matrix}$
sind linear unabhängig. Da der Code die Dimension k=4 hat, ist die Indexmenge J codewortbestimmend.
Die Matrix $M= \begin{matrix} 1111 \\ 0111 \\ 0001 \\ 1011 \end{matrix}$
ist invertierbar. Die zugehörige inverse Matrix ist $M^{- 1} = \begin{matrix} 1100 \\ 1001 \\ 1111 \\ 0010 \end{matrix}$
$y=P'+H=1111 1011 .$
Die 2., 5., 6. Und 8. Komponente von y liefern den Stützvektor b = 1101.
(Der Vektor b hat bereits die richtige Länge k=4, das heißt b'=b.)
Eine Anwendung von Satz 5 ergibt ${c=b'M}^{- 1} G= (1101) M^{- 1} G= (0111) G=0110 1001 .$
Daher ist P = c+H = 1110 0111, und e = P'+P= 1001 0010.
In Beispiel 1 konnte der wahre PUF-Wert P rekonstruiert werden, obwohl drei Fehler in P' aufgetreten sind. Da der zugrundeliegende Code die Minimumdistanz d=4 hat, können auf mit Hilfe eines Decoders (der gemäß dem verwendeten Code Fehler korrigiert) nur 1-Bitfehler korrigiert werden.
Beispiel 2 zur PUF-Rekonstruktion:
Betrachtet wird eine PUF der Länge n=31.
Der verwendete lineare Code sei der (31, 5, 16) Simplex Code, dessen Codewörter die 32 linear rekursiven Folgen sind, die die Rekursion $s_{(m+5)} = s_{(m+2)} + s_{m} für m=0,1, \dots$
erfüllen. Der Code hat die Generatormatrix $G= \begin{matrix} 10000 & 10010 & 11001 & 11110 & 00110 & 11101 & 0 \\ 01000 & 01001 & 01100 & 11111 & 00011 & 01110 & 1 \\ 00100 & 10110 & 01111 & 10001 & 10111 & 01010 & 0 \\ 00010 & 01011 & 00111 & 11000 & 11011 & 10101 & 0 \\ 00001 & 00101 & 10011 & 11100 & 01101 & 11010 & 1 \end{matrix}$
Der aktuelle PUF-Wert P', der Hilfsvektor H, und der aktuelle Zustand R des kumulativen Fehlerregisters seien gegeben durch $\begin{matrix} P' & = 00011 & 11110 & 01001 & 01011 & 01011 & 01101 & 1 \\ H & = 11110 & 00111 & 01000 & 10101 & 11110 & 01100 & 1 \\ R & = 11111 & 10110 & 11111 & 11101 & 11101 & 10101 & 1 \end{matrix}$
Daher ist J = {7, 10, 19, 24, 27, 29}.
Die Dimension des Codes ist k=5.
Die fünf Spaltenvektoren L₁ = G₇, L₂ = G₁₀, L₃ = G₁₉, L₄ = G₂₄ und L₅ = G₂₇ sind linear unabhängig. Daher ist $M= \begin{matrix} 00111 \\ 11111 \\ 00011 \\ 11010 \\ 01001 \end{matrix} {und M}^{- 1} = \begin{matrix} 00111 \\ 11111 \\ 10100 \\ 11010 \\ 11110 \end{matrix}$
$y=P'+H= \begin{matrix} 11101 & 11001 & 00001 & 11110 & 10101 & 00001 & 0 \end{matrix}$
Der Stützvektor b ist: b = 1 1 1 0 0 0
Und der reduzierte Stützvektor b' ist: b' = 1 1 1 0 0
Aus Satz 5 folgt ${c=b'M}^{- 1} G= (01100) G= \begin{matrix} 01100 & 11111 & 00011 & 01110 & 10100 & 00100 & 1 \end{matrix}$
Daraus ergibt sich der wahre PUF-Wert P: $P=H+c= \begin{matrix} 10010 & 11000 & 01011 & 11011 & 01010 & 01000 & 0 \end{matrix}$
Der Fehlervektor e ist: $e=P'+P= \begin{matrix} 10001 & 00110 & 00010 & 10000 & 00001 & 00101 & 1 \end{matrix}$
Beispiel 3 zur PUF-Rekonstruktion:
PUF-Länge: n = 16. $P'= \begin{matrix} 0100 & 1100 & 0001 & 0111 \end{matrix}$
$H= \begin{matrix} 1110 & 0110 & 0101 & 0111 \end{matrix}$
Der zugrundeliegende Code sei der (16, 5, 8) Reed-Muller Code mit Generatormatrix $G= \begin{matrix} 1111 & 1111 & 1111 & 1111 \\ 0000 & 0000 & 1111 & 1111 \\ 0000 & 1111 & 0000 & 1111 \\ 0011 & 0011 & 0011 & 0011 \\ 0101 & 0101 & 0101 & 0101 \end{matrix}$
Der Zustand des kumulativen Fehlerregisters sei R = 1101 1101 1101 1011.
Daher ist: J = {3, 7, 11, 14}.
Da die Dimension des Codes k=5 ist, die Indexmenge J aber nur vier Elemente enthält, ist Satz 5 nicht direkt anwendbar. Es werden dennoch die mit J assoziierten vier Spaltenvektoren der Generatormatrix G betrachtet, nämlich die Vektoren $G_{3} = \begin{matrix} 1 \\ 0 \\ 0 \\ 1 \\ 0 \end{matrix}, G_{7} = \begin{matrix} 1 \\ 0 \\ 1 \\ 1 \\ 0 \end{matrix}, G_{11} = \begin{matrix} 1 \\ 1 \\ 0 \\ 1 \\ 0 \end{matrix}, G_{14} = \begin{matrix} 1 \\ 1 \\ 1 \\ 0 \\ 1 \end{matrix};$
Die vier Vektoren sind linear unabhängig. Daher hat die 5x4 Matrix $G_{J} = (G_{3}, G_{7}, G_{11}, G_{14}) = \begin{matrix} 1 & 1 & 1 & 1 \\ 0 & 0 & 1 & 1 \\ 0 & 1 & 0 & 1 \\ 1 & 1 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{matrix}$
den Rang 4.
Es wird wieder der Vektor y berechnet: $y=P'+H= \begin{matrix} 1010 & 1010 & 0100 & 0000 \end{matrix}$
Wegen J = {3, 7, 11, 14} ergeben sich die 3., 7., 11. und 14. Komponente des zu bestimmenden Codeworts c zu $\begin{matrix} c_{3} = y_{3} = 1, & c_{7} = y_{7} = 1, & c_{11} = y_{11} = 0, & c_{14} = y_{14} = 0. \end{matrix}$
Sei v = (v1, v2, v3, v4, v5) der zu c gehörige Nachrichtenvektor.
Aus $vG=c$
folgt insbesondere, dass ${v G}_{J} = (c3,c7,c11,c14) .$
Das heißt: $\begin{matrix} v_{1} & {+v}_{4} & = 1 \\ v_{1} & + v_{3} + v_{4} & = 1 \\ v_{1} + v_{2} & + v_{4} & = 0 \\ v_{1} + v_{2} + v_{3} & + v_{5} = 0 \end{matrix}$
Dies ist ein System von vier linearen Gleichungen in den fünf Unbekannten v₁, ..., v₅.
Da die Koeffizientenmatrix G_J den Rang 4 hat, gibt es genau zwei Lösungsvektoren: $v_{1} = 01011 {und v}_{2} = 11000.$
Daher existieren auch zwei Lösungen für das gesuchte Codewort c, nämlich $c_{1} = v_{1} G= \begin{matrix} 0110 & 0110 & 1001 & 1001 \end{matrix},$
und $c_{2} = v_{2} G= \begin{matrix} 1111 & 1111 & 0000 & 0000 \end{matrix} .$
Den beiden Codewortkandidaten entsprechen zwei PUF-Wert-Kandidaten: $P_{1} = c_{1} + H= \begin{matrix} 1000 & 0000 & 1100 & 1110 \end{matrix},$
und $P_{2} = c_{2} + H= \begin{matrix} 0001 & 1001 & 0101 & 0111 \end{matrix} .$
Die beiden zugehörigen Fehlervektoren sind: $e_{1} = P_{1} + P'= \begin{matrix} 1100 & 1100 & 1101 & 1001 \end{matrix},$
und $e_{2} = P_{2} + P'= \begin{matrix} 0101 & 0101 & 0100 & 0000 \end{matrix} .$
Da e₁ neun Einsen, e₂ dagegen nur fünf Einsen enthält, stellt der PUF-Wert P₂ eine bessere Approximation an den aktuellen PUF-Wert P' dar. Es wird daher P₂ als der wahrscheinlichere Kandidat für den wahren PUF-Wert P gewählt, d.h. P = P₂.
Das kumulative Fehlerregister wird nicht von Anfang an genutzt, sondern wird erst nach einer bestimmten Anzahl von PUF-Wert-Erzeugungen genutzt. Dies wird im Folgenden erläutert.
Sei dazu wie oben P der (beispielsweise in der Fabrik) festgelegte wahre PUF-Wert. Seien P₀, P₁, P₂, ... der erste, zweite, dritte, ... generierte aktuelle PUF-Wert. Mit dem Hilfsvektor H werden die Vektoren y₀=H+P₀, y₁=H+P₁, y₂=H+P₂, ... berechnet. Die Vektoren y₀, y₁, y₂, ... werden in den Decoder eingegeben, der daraufhin die zugehörigen Fehlervektoren e₀, e₁, e₂, ... berechnet. Aus den Fehlervektoren und dem Initialisierungsvektor R₀ ergeben sich die Zustände R₁, R₂, R₃, ... des kumulativen Fehlerregisters.
Angenommen zum Zeitpunkt t=3 befindet sich in einer bestimmten Zelle des kumulativen Fehlerregisters der Wert 0. Dann kann nicht davon ausgegangen werden, dass die entsprechende PUF-Komponente quasistabil ist. Diese Annahme wäre aber etwa dann angebracht, wenn zum Zeitpunkt t=3000 (beispielsweise) dort eine 0 steht - was bedeutet, dass im Laufe der ersten 3000 PUF-Wert-Generierungen in dieser Komponente niemals ein Fehler aufgetreten ist.
Die Zeitspanne während der das kumulative Fehlerregister noch nicht genutzt werden kann, wird als Aufbauphase bezeichnet.
Es stellt sich die Frage, wie lange die Aufbauphase dauert. Anders ausgedrückt ist es von Interesse, zu wissen, wie oft (mindestens) das kumulative Fehlerregister aktualisiert mit einem vom Decoder gelieferten Fehlervektor werden muss, bevor es genutzt werden kann (d.h. bis es verlässliche Angaben über die quasistabilen Komponenten liefert).
Der Zeitpunkt, ab dem das kumulative Fehlerregister einsatzbereit ist, wird beispielsweise ermittelt, indem berechnet wird, ab wann die Wahrscheinlichkeit für einen Fehler bei der Codewortrekonstruktion (basierend auf der Information in dem kumulativen Fehlerregister) kleiner ist als die Wahrscheinlichkeit für einen Decoder-Fehler.
Es ergibt sich:
Für eine PUF der Länge n mit durchschnittlicher Fehlerrate p und der Verwendung eines linearer (n, k, d) Codes ist das kumulative Fehlerregister zu einem Zeitpunkt t einsetzbar, wenn $t > 1 / (1 - B^{1 / k}) mit B = \sum_{j = 0}^{b} (\begin{matrix} n \\ j \end{matrix}) p^{j} {(1 - p)}^{n - j}$
wobei b die größte ganze Zahl mit b < d/2 ist.
Beispiel:
PUF-Länge sei n=16.
Durchschnittliche Fehlerrate ist 10%, das heißt p=0.1.
Der zugrundeliegende Code sei der (16, 5, 8) Reed-Muller Code.
Es ist B = (1-p)¹⁶ + 16 p (1-p)¹⁵ + 120 p² (1-p)¹⁴ + 560 p³ (1-p)¹³ und 1/(1-B^1/5) = 71,064.
Deshalb wird gemäß einer Ausführungsform das kumulative Fehlerregister 72 mal aktualisiert bevor es verwendet wird.
4 zeigt eine Anordnung 400, die unterschiedliche Betriebsmodi für die PUF-Rekonstruktion, insbesondere eine PUF-Rekonstruktion gemäß Satz 6, ermöglicht.
Die Anordnung weist ein PUF-Modul 401, einen Decoder 402, eine Steuereinrichtung 403, ein kumulatives Fehlerregister 404 und einen Codewort-Generator 405 auf.
Die Anordnung 400 ist beispielsweise Teil des PUF-Wert-Rekonstruktionsmoduls 107.
Ein erster Addierer 406 addiert die Hilfsdaten H (die z.B. im Speicher 103 gespeichert sind) zu dem vom PUF-Modul 401 gelieferten aktuellen PUF-Wert P_t.
Das Resultat y_t wird über eine erste Sperre 407, wenn sie offen ist, dem Decoder 402 zugeführt. Der Decoder 402 ermittelt den zugehörigen Fehlervektor e_t oder das zugehörige Codewort C, wenn er nicht überfordert ist, weil zu viele Fehler passiert sind. Aus e_t bzw. c wird wie oben beschrieben der wahre PUF-Wert rekonstruiert.
Außerdem wird das Resultat y_t über eine zweite Sperre 408, wenn sie offen ist, dem Codewortgenerator 405 zugeführt, der, unter Verwendung der Informationen über quasistabile Komponenten, die er von dem kumulativen Fehlerregister 404 erhält, das beispielsweise wie mit Bezug auf 2 oder 3 beschrieben gefüllt wird, eine PUF-Rekonstruktion gemäß Satz 6 durchführt.
Die Steuereinrichtung 403 kann den Stand des kumulativen Fehlerregisters auslesen. Die Steuereinrichtung 403 kann das kumulative Fehlerregister auch auf den Anfangszustand „Alles-Null“ zurückstellen (Reset). Die Steuereinrichtung 403 öffnet und schließt die Sperren 407, 408 beispielsweise gemäß einem der folgenden Betriebsmodi:
Decoder bevorzugt: Sperre 407 offen, Sperre 408 zu.
Wenn der Decoder 402 seine Aufgabe erledigen konnte, weil nicht zu viele Fehler passiert sind, wird der Codewort-Generator 405 nicht verwendet. Nur für den Fall, dass der Decoder 402 die Korrektur nicht bewältigen kann und diese Information der Steuereinrichtung 403 mitteilt, kommt der Codewort-Generator 405zum Einsatz.
Codewort-Generator bevorzugt: Sperre 407 zu, Sperre 408 offen.
Der Decoder 402 wird nur während der Aufbauphase benutzt, um das kumulative Fehlerregister aufzubauen. Danach wird das Codewort c (aus dem sich dann sofort der wahre PUF-Wert P ergibt) immer mit dem Codewort-Generator 405 berechnet.
Doppelberechnung: Beide Sperren 407, 408 offen.
Das Codewort c (und damit der wahre PUF-Wert P) werden auf zweifache Art berechnet: Mit dem Decoder 405 und mit dem Codewort-Generator 408.
Zusammenfassend wird gemäß verschiedenen Ausführungsformen eine Datenverarbeitungseinrichtung bereitgestellt, wie sie in 5 dargestellt ist.
5 zeigt eine Datenverarbeitungseinrichtung 500.
Die Datenverarbeitungseinrichtung 500 weist eine PUF-Wert-Quelle 501 auf, die dazu eingerichtet ist, einen Referenz-PUF-Wert und mehrere nachfolgende PUF-Werte zu liefern, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist.
Die Datenverarbeitungseinrichtung 500 weist ferner eine Ermittlungseinrichtung 502 auf, die eingerichtet ist, eine Menge von Komponenten zu ermitteln, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist.
Weiterhin weist die Datenverarbeitungseinrichtung eine PUF-Rekonstruktionseinrichtung 503 auf, die eingerichtet ist, den Referenz-PUF-Wert aus den nachfolgenden PUF-Werten ausgehend von der Annahme zu rekonstruieren, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen.
In anderen Worten ist gemäß verschiedenen Ausführungsbeispiel eine Einrichtung zur Ermittlung der Positionen quasistabiler PUF-Komponenten vorgesehen und bei Existenz und die Werte der quasistabilen Komponenten des aktuellen PUF-Werts werden zur PUF-Rekonstruktion verwendet (beispielsweise bei Existenz und Kenntnis hinreichend vieler geeigneter quasistabiler PUF-Komponentenpositionen). Die PUF-Rekonstruktion erfolgt beispielsweise mittels eines Algorithmus zur Berechnung eines Codeworts aus bestimmten bekannten Komponenten des Codeworts.
Die Komponenten der Datenverarbeitungseinrichtung (wie beispielsweise die Ermittlungseinrichtung und die PUF-Rekonstruktionseinrichtung) können durch ein oder mehrere Schaltkreise realisiert sein. In einer Ausführungsform ist ein „Schaltkreis“ als jegliche Einheit zu verstehen, die eine Logik implementiert, und die sowohl Hardware, Software, Firmware oder eine Kombination daraus sein kann. Somit kann ein „Schaltkreis“ in einer Ausführungsform ein hart-verdrahteter Logik-Schaltkreis oder ein programmierbarer Logik-Schaltkreis sein, wie beispielsweise ein programmierbarer Prozessor. Unter einem „Schaltkreis“ kann auch ein Prozessor, der Software ausführt, zu verstehen sein, z.B. jegliche Art von Computer-Programm. Unter einem „Schaltkreis“ kann in einer Ausführungsform jegliche Art der Implementierung der im Weiteren beschriebenen Funktionen zu verstehen sein.
Die Datenverarbeitungseinrichtung 500 führt beispielsweise ein Verfahren zum Rekonstruieren eines PUF-Werts auf, wie es in 6 dargestellt ist.
6 zeigt ein Ablaufdiagramm gemäß einer Ausführungsform.
In 601 werden ein Referenz-PUF-Wert und mehrere nachfolgende PUF-Werte aus einer PUF-Wert-Quelle ausgelesen, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist.
In 602 wird eine Menge von Komponenten, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist, ermittelt.
In 603 wird der Referenz-PUF-Wert aus den nachfolgenden PUF-Werten ausgehend von der Annahme, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen, rekonstruiert.
Im Folgenden werden weitere Ausführungsformen beschrieben.
Ausführungsform 1 ist eine Datenverarbeitungseinrichtung, wie sie in 1 dargestellt ist, wobei die PUF-Rekonstruktionseinrichtung eingerichtet ist, den Referenz-PUF-Wert basierend auf den Hilfsdaten zu rekonstruieren, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren, und wobei der Code ein linearer Code ist, und den Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes zu rekonstruieren.
Ausführungsform 2 ist eine Datenverarbeitungseinrichtung gemäß Ausführungsform 1, wobei die Hilfsdaten die Summe aus dem Referenz-PUF-Wert und einem Codewort eines Codes ist.
Ausführungsform 3 ist eine Datenverarbeitungseinrichtung gemäß Ausführungsform 1 oder 2, wobei die PUF-Rekonstruktionseinrichtung eingerichtet ist, den Referenz-PUF-Wert durch Ermitteln des Codeworts zu rekonstruieren.
Ausführungsform 4 ist eine Datenverarbeitungseinrichtung gemäß einer der Ausführungsformen 1 bis 3, aufweisend ein PUF-Modul zum Auslesen der nachfolgenden PUF-Werte aus der PUF-Quelle.
Ausführungsform 5 ist eine Datenverarbeitungseinrichtung gemäß einer der Ausführungsformen 1 bis 4, wobei die PUF-Quelle ein physikalisches Objekt ist.
Ausführungsform 6 ist eine Datenverarbeitungseinrichtung gemäß einer der Ausführungsformen 1 bis 5,
wobei die PUF-Quelle eine Komponente einer Chipkarte ist.
Ausführungsform 7 ist eine Datenverarbeitungseinrichtung gemäß einer der Ausführungsformen 1 bis 6, wobei die Datenverarbeitungseinrichtung ein Chipkartenmodul ist.
Ausführungsform 8 ist eine Datenverarbeitungseinrichtung gemäß einer der Ausführungsformen 1 bis 7, wobei die Ermittlungseinrichtung eingerichtet ist, die Menge von Komponenten, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist, durch ODER-Verknüpfen der Fehlervektoren der nachfolgenden PUF-Werte zu ermitteln.
Ausführungsform 9 ist eine Verfahren zum Rekonstruieren eines PUF-Werts wie es teilweise in 6 dargestellt ist, wobei ein Speichern von Hilfsdaten zur Rekonstruktion des Referenz-PUF-Werts erfolgt, und wobei ferner der Referenz-PUF-Wert basierend auf den Hilfsdaten rekonstruiert wird, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren, wobei der Code ein linearer Code ist und wobei der Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes rekonstruiert wird.

Claims

Datenverarbeitungseinrichtung aufweisend Eine PUF-Wert-Quelle, die dazu eingerichtet ist, einen Referenz-PUF-Wert und mehrere nachfolgende PUF-Werte zu liefern, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist; Eine Ermittlungseinrichtung, die eingerichtet ist, eine Menge von Komponenten zu ermitteln, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist; Einen Speicher zum Speichern von Hilfsdaten zur Rekonstruktion des Referenz-PUF-Werts; und Eine PUF-Rekonstruktionseinrichtung, die eingerichtet ist, den Referenz-PUF-Wert aus den nachfolgenden PUF-Werten ausgehend von der Annahme zu rekonstruieren, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen, den Referenz-PUF-Wert basierend auf den Hilfsdaten zu rekonstruieren, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren und wobei der Code ein linearer Code ist, und den Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes zu rekonstruieren.
Datenverarbeitungseinrichtung gemäß Anspruch 1, wobei die Hilfsdaten die Summe aus dem Referenz-PUF-Wert und einem Codewort eines Codes ist.
Datenverarbeitungseinrichtung gemäß Anspruch 1 oder 2, wobei die PUF-Rekonstruktionseinrichtung eingerichtet ist, den Referenz-PUF-Wert durch Ermitteln des Codeworts zu rekonstruieren.
Datenverarbeitungseinrichtung gemäß einem der Ansprüche 1 bis 3, aufweisend ein PUF-Modul zum Auslesen der nachfolgenden PUF-Werte aus der PUF-Quelle.
Datenverarbeitungseinrichtung gemäß einem der Ansprüche 1 bis 4, wobei die PUF-Quelle ein physikalisches Objekt ist.
Datenverarbeitungseinrichtung gemäß einem der Ansprüche 1 bis 5, wobei die PUF-Quelle eine Komponente einer Chipkarte ist.
Datenverarbeitungseinrichtung gemäß einem der Ansprüche 1 bis 6, wobei die Datenverarbeitungseinrichtung ein Chipkartenmodul ist.
Datenverarbeitungseinrichtung gemäß einem der Ansprüche 1 bis 7, wobei die Ermittlungseinrichtung eingerichtet ist, die Menge von Komponenten, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist, durch ODER-Verknüpfen der Fehlervektoren der nachfolgenden PUF-Werte zu ermitteln.
Verfahren zum Rekonstruieren eines PUF-Werts aufweisend: Auslesen eines Referenz-PUF-Werts und mehrerer nachfolgender PUF-Werte aus einer PUF-Wert-Quelle, wobei der Referenz-PUF-Wert und jeder nachfolgende PUF-Wert eine Vielzahl von binären Komponenten aufweist; Ermitteln einer Menge von Komponenten, deren Wert bei den mehreren nachfolgenden PUF-Werten gleich ist; Speichern von Hilfsdaten zur Rekonstruktion des Referenz-PUF-Werts; Rekonstruieren des Referenz-PUF-Werts aus den nachfolgenden PUF-Werten ausgehend von der Annahme, dass die Werte der ermittelten Komponenten bei dem nachfolgenden PUF-Wert mit den Werten der ermittelten Komponenten bei dem Referenz-PUF-Wert übereinstimmen, wobei der Referenz-PUF-Wert basierend auf den Hilfsdaten rekonstruiert wird, wobei die Hilfsdaten auf dem Referenz-PUF-Wert und einem Codewort eines Codes basieren, wobei der Code ein linearer Code ist und wobei der Referenz-PUF-Wert durch Auswahl von linear unabhängigen Spalten der Spalten, die den ermittelten Komponenten entsprechen, und Multiplikation der Inversen Matrix zu einer aus den ausgewählten Spalten gebildeten Matrix mit der Generatormatrix des Codes rekonstruiert wird.