DE102018113475A1 - Rechenwerk zum rechnen mit maskierten daten - Google Patents

Abstract

Gemäß einer Ausführungsform wird ein Rechenwerk beschrieben, das eine Maskenerzeugungsschaltung, die eingerichtet ist, eine Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes zu erzeugen, eine Maskierungsschaltung, die eingerichtet ist, zu verarbeitende Daten mittels der Maske zu maskieren, und eine arithmetisch-logische Einheit aufweist, die eingerichtet ist, die maskierten Daten mittels Additionen und Rotationen zu verarbeiten.

Description

• Ausführungsbeispiele betreffen allgemein Rechenwerke zum Rechnen mit maskierten Daten.
• Im Rahmen von sicherheitsrelevanten Anwendungen führen Computerchips, wie beispielsweise auf einer Chipkarte oder in einer Steuervorrichtung in einem Fahrzeug typischerweise kryptographische Operationen zur Verschlüsselung, Entschlüsselung und Authentifizierung etc. durch. Dabei werden Daten verarbeitet, wie beispielsweise kryptographische Schlüssel, die vor einem Zugriff durch einen Angreifer geschützt werden sollen. Ein typischer Sicherheitsmechanismus ist die Maskierung von zu verarbeitenden Daten. Da die Maskierung und die Verarbeitung maskierter Daten aber zusätzlichen Rechenaufwand (und entsprechenden Hardwareaufwand) erfordert, sind Rechenwerke wünschenswert, die mit geringem zusätzlichen Hardwareaufwand das Rechnen mit maskierten Daten ermöglichen.
• Gemäß einer Ausführungsform wird ein Rechenwerk bereitgestellt, das eine Maskenerzeugungsschaltung, die eingerichtet ist, eine Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes zu erzeugen, eine Maskierungsschaltung, die eingerichtet ist, zu verarbeitende Daten mittels der Maske zu maskieren, und eine arithmetisch-logische Einheit aufweist, die eingerichtet ist, die maskierten Daten mittels Additionen und Rotationen zu verarbeiten.
• 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 ein Beispiel für eine Verarbeitungsvorrichtung zur Durchführung kryptographischer Operationen.
• 2 veranschaulicht eine Realisierung einer Multiplikation in Hardware.
• 3 zeigt eine maskierte ALU gemäß einer Ausführungsform.
• 4 zeigt ein Gatter zum Implementieren einer maskierten UND-Verknüpfung.
• 5 zeigt ein Rechenwerk gemäß einer Ausführungsform.
• 6 zeigt ein Flussdiagram, das ein Verfahren zum Rechnen mit maskierten Daten gemäß einer Ausführungsform 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.
• 1 zeigt ein Beispiel für eine Verarbeitungsvorrichtung 100 mit einer CPU 101, einem RAM (Random Access Memory) 102, einem nichtflüchtigen Speicher 103 (NVM), einem Krypto-Modul 104, einem Analogmodul 106, einer Eingabe-/Ausgabeschnittstelle 107 und einem Hardware-Zufallszahlengenerator 112.
• In diesem Beispiel hat die CPU 101 Zugriff auf mindestens ein Krypto-Modul 104 über einen gemeinsamen Bus 105, mit dem jedes Krypto-Modul 104 verbunden ist. Jedes Krypto-Modul 104 kann insbesondere einen oder mehrere Krypto-Kerne umfassen, um bestimmte kryptographische Operationen durchzuführen. Beispielhafte Kryptokerne sind:
• - ein AES-Kern 109,
• - ein SHA-Kern 110,
• - ein ECC-Kern 111, und
• - ein Gitter-basierter Krypto- (LBC) -Kern 108.
• Der gitterbasierte Kryptokern 108 kann vorgesehen sein, um gitterbasierte Kryptographie zu beschleunigen.
• Die CPU 101, der Hardware-Zufallszahlengenerator 112, das NVM 103, das Kryptomodul 104, das RAM 102 und die Eingabe/Ausgabe-Schnittstelle 107 sind mit dem Bus 105 verbunden. Die Eingabe-Ausgabeschnittstelle 107 kann eine Verbindung 114 zu anderen Vorrichtungen ähnlich der Verarbeitungsvorrichtung 100 haben.
• Das Analogmodul 106 wird über einen elektrischen Kontakt und/oder über ein elektromagnetisches Feld mit elektrischer Energie versorgt. Diese Energie wird zugeführt, um die Schaltung der Verarbeitungsvorrichtung 100 anzutreiben, und kann insbesondere ermöglichen, dass die Eingabe/Ausgabe-Schnittstelle über die Verbindung 114 Verbindungen zu anderen Vorrichtungen einleitet und/oder aufrechterhält.
• Der Bus 105 selbst kann maskiert oder einfach sein. Anweisungen zum Ausführen der Verarbeitung und der Algorithmen, die im Folgenden beschrieben werden, können insbesondere in dem NVM 103 gespeichert und von der CPU 101 verarbeitet werden. Die verarbeiteten Daten können in dem NVM 103 oder in dem RAM 102 gespeichert werden. Zufallszahlen werden von dem Hardware-Zufallszahlengenerator 112 geliefert.
• Die Verarbeitung und die Algorithmen, die im Folgenden beschrieben werden, können ausschließlich oder zumindest teilweise auf dem Kryptomodul 104 ausgeführt werden. Ein Kryptomodul 104 kann mit hardwarebasierten Sicherheitsmechanismen ausgestattet werden. Solche hardwarebasierten Sicherheitsmechanismen können Schaltungen sein, die Gegenmaßnahmen gegen Seitenkanal-Leistungsanalyse oder Fehlerinjektion implementieren (z. B. unter Verwendung eines Lasers). Solche Gegenmaßnahmen könnten durch Verwendung von Randomisierung, redundanter Hardware oder redundanter Verarbeitung realisiert werden. Im Allgemeinen ist es das Ziel von Gegenmaßnahmen, die intern verarbeiteten Werte und Zwischenergebnisse vor einem Angreifer zu verbergen, der in der Lage ist, den physikalischen Effekt der Verarbeitung solcher Werte zu beobachten.
• Die Komponenten der Verarbeitungsvorrichtung 100 können beispielsweise auf einem einzigen Chip implementiert sein. Die Verarbeitungsvorrichtung 100 kann eine Chipkarte (oder ein Chipkartenmodul) sein, die durch direkten elektrischen Kontakt oder durch ein elektromagnetisches Feld versorgt wird. Die Verarbeitungsvorrichtung 100 kann eine feste Schaltung sein oder auf rekonfigurierbarer Hardware basieren (z. B. Field Programmable Gate Array, FPGA). Die Verarbeitungsvorrichtung 100 kann mit einem Personal Computer, Mikrocontroller, FPGA oder einem Smartphone-System auf einem Chip (SoC) oder anderen Komponenten eines Smartphones verbunden sein. Die Verarbeitungsvorrichtung 100 kann ein Chip sein, der als Trusted Platform Module (TPM) fungiert und kryptografische Funktionalität gemäß einer standardisierten Schnittstelle zu einem Computer, Smartphone, Internet der Dinge (IoT) Gerät oder Fahrzeug bereitstellt.
• Seriell-parallel Multiplizierer für Langzahlen sind eine Kernkomponente vieler kryptographischer Co-Prozessoren (wie der Krypto-Module 104) zur effizienten Berechnung von Public-Key Kryptoverfahren wie RSA oder Kryptographie mit elliptischen Kurven. Solche Multiplizierer werden beispielsweise in den Langzahlrechenwerken von Chipkarten oder in Authentisierungstoken verwendet.
• Ein seriell-parallel arbeitender Multiplizierer für Langzahlen besteht aus einem Langzahl-Register (Accu), dem Akkumulator, zum Speichern von Zwischenergebnissen der Multiplikation, einer Addier-Einheit, einem Schieber (Shifter) und Komponenten zur Berechnung von Partialprodukten von Operanden und Reduktionswerten. Während einer Multiplikation wird einer der zu multiplizierenden Operanden parallel und der andere Operand seriell bezüglich der verwendeten Zahldarstellung (typischerweise Bit-seriell für Operanden in Binärdarstellung) verwendet. Zu Beginn einer Multiplikation wird der Accu normalerweise auf Null gesetzt. Dann wird in einer Schleife der aktuelle Inhalt des Accus um eine Stelle geschoben und es werden Partialprodukte des ersten Operanden (in Abhängigkeit von einer Stelle des zweiten Operanden) sowie Reduktionswerte (in Anhängigkeit vom aktuellen Inhalt des Accus) addiert. Dabei kann der seriell verwendete Operand beginnend bei der höchstwertigen oder beginnend bei der niedrigstwertigen Stelle verarbeitet werden. Insbesondere zur Implementierung von Protokollen für elliptische Kurven über endlichen Körpern GF(2ⁿ) der Charakteristik 2 ist die Verwendung solcher Multiplizierer auf Grund der einfachen Schaltungsanordnung, des geringen Flächenbedarfs und der hohen Ausführungsgeschwindigkeit vorteilhaft.
• Durch die serielle Abarbeitung eines der Operanden sind solche Multiplizierer aber inhärent anfällig gegen Angriffe auf die Vertraulichkeit von Daten. Oft ist es ausreichend, wenn ein Angreifer lediglich ein einzelnes Signal der Schaltungsanordnung beispielsweise mittels einer Probing-Nadel beobachtet, um an den vollständigen Inhalt der im Multiplizierer verarbeiteten Operanden zu kommen, weil durch die serielle Datenverarbeitung der komplette Wert von Operanden und/oder berechneten Werten durch das beobachtete Register geschoben wird.
• Ein Sicherheitsmechanismus gegen das Auslesen von Daten durch einen Angreifer ist die Maskierung von Daten. Typischerweise werden zur Maskierung von vertraulichen Daten und Operanden Secret-Sharing-Schemes verwendet. Bei einem d-aus-n Secret-Sharing-Scheme wird ein zu schützendes Bit b ∈ {0, 1} als Tupel (b₁, ..., b_n) ∈ {0, 1}ⁿ von n sogenannten Shares gespeichert, wobei gilt, dass
• • aus der Kenntnis von beliebigen d Bits b_i1, ..., b_id des Tupels (b₁, ..., b_n) ∈ {0, 1}ⁿ mit 1 ≤ i₁ < i₂ < ... < i_d ≤ n der Wert des gespeicherten Bits b eindeutig rekonstruiert werden kann und
• • die Kenntnis von weniger als d Bits des Tupels (b₁, ..., b_n) ∈ {0, 1}ⁿ keine Information (im informationstheoretischen Sinn) über das gespeicherte Bit liefert.
• Ein d-aus-n Secret-Sharing-Scheme definiert eine Familie von Wahrscheinlichkeitsverteilungen mit den Eigenschaften, dass weniger als d Verteilungen statistisch unabhängig sind und d oder mehr Verteilungen voneinander abhängen, wobei die Abhängigkeit durch das zu schützende Bit b gegeben ist.
• Bei einer einfachen Implementierung eines n-aus-n Secret-Sharing-Schemes werden n-1 identisch gleichverteilte und unabhängige Zufallsbits b₁, ..., b_n-1 erzeugt. Das Bit b_n wird dann durch b_n := b₁ ⊕ ... ⊕ b_n-1 ⊕ b definiert. Bei dieser Vorgehensweise wird die zu speichernde Information jedoch auf das n-fache vergrößert. Bei einem Langzahlrechenwerk ist die n-fache Berechnung und Speicherung der benötigten Langzahlen und Zwischenergebnisse typischerweise nicht praktikabel.
• Alternativ kann die Prüfmatrix eines (n, k, d) linearen Codes mit Code-Wortlänge n, Dimension k und Minimaldistanz d zur Erzeugung geeigneter Maskierungen verwendet werden. Die Code-Wörter haben nach Konstruktion die Eigenschaft, dass keine Linearkombination aus weniger als d Code-Wörtern den Nullvektor ergeben kann. Wenn die Code-Wörter als die Spalten einer n × 2^k Matrix M aufgefasst werden, so lassen sich durch Matrixmultiplikation r*M mit einem n-bit Zufallsvektor (Maskenerzeugungsvektor) r bis zu 2^k Maskierungsbits erzeugen. Diese Maskierungsbits haben die Eigenschaft, dass bis zu d-1 maskierte Datenbits und Bits des Zufallsvektors keine Information über die maskierten Daten liefern. Mit Hilfe dieser Konstruktion ist es möglich, sehr kompakte d-aus-n Secret-Sharing-Schemes zu erzeugen, welche deutlich weniger Speicherplatz benötigen als das beschriebene einfache Maskierungsverfahren. Dabei werden lediglich die maskierten Daten und der Zufallsvektor r zur Erzeugung der Maskenbits gespeichert. Die zugehörigen Maskenbits können on-the-fly unter Verwendung der Matrix M zum Maskieren und Demaskieren von Daten berechnet werden und müssen daher nicht gespeichert werden.
• Im Allgemeinen ist es bei d-aus-n Secret-Sharing-Schemes zur Maskierung vertraulicher Daten jedoch nicht möglich, alle zur Durchführung einer Multiplikation für Langzahlen benötigten Rechenoperationen direkt auf den maskierten Daten auszuführen. Um direkt mit maskierten Daten rechnen zu können, muss das verwendete Maskierungsverfahren geeignete Homomorphieeigenschaften aufweisen. Das bedeutet, dass die Schritte zur Datenmaskierung und die Rechenoperationen vertauscht werden können: Das Ergebnis darf sich nicht ändern, wenn zuerst die Daten bezüglich einer Rechenoperation verknüpft und anschließend maskiert werden oder wenn zuerst die Operanden maskiert und anschließend mit einer (dann möglicherweise unterschiedlichen) Rechenoperation verknüpft werden. Eine solche Homomorphie ermöglicht es, direkt mit maskierten Operanden zu rechnen.
• Es ist möglich, effiziente Maskierungsschemata zu finden, welche mit einer der benötigten Rechenoperationen homomorph sind: So sind zum Beispiel lineare Codes über GF(2ⁿ) mit der bitweisen XOR(exklusives ODER)-Operation vertauschbar und Restklassencodes modulo Z/nZ mit der Integer-Addition vertauschbar. Es existieren aber häufig keine geeigneten Maskierungsverfahren, welche mit allen benötigten Rechenoperationen vertauschbar sind. Für den Fall eines Langzahlmultiplizierers für GF(2ⁿ) muss das Maskierungsverfahren mindestens mit der bitweisen XOR-Operation und Schiebe-Operationen vertauschbar sein. Das beschriebene einfache Maskierungsverfahren eines n-aus-n Secret-Sharing-Schemes besitzt zwar alle dafür benötigten Homomorphieeigenschaften, ist aber (wie auch andere zyklische lineare Codes) ineffizient bezüglich des notwendigen Speicherplatzes für die Shares der maskierten Daten.
• Im Folgenden wird eine Vorgehensweise zur Konstruktion speicherplatzeffizienter Maskierungsschemata beschrieben, welche mit bitweiser XOR-Operation homomorph sind und nur wenige Bitfehler bezüglich der Homomorphie mit (zyklischen) Schiebe-Operationen aufweisen. Diese Eigenschaften sind ausreichend, um einen bezüglich Gatterkomplexität, Flächenbedarf und Leistungsaufnahme optimierten, vollständig maskiert rechnenden Langzahlmultiplizierer über GF(2ⁿ) implementieren zu können, wie er beispielsweise für kryptographische Protokolle basierend auf elliptischen Kurven über endlichen Körpern der Charakteristik 2 benötigt wird. Durch die Maskierungsschemata wird eine Randomisierung von internen Zuständen, welche von außen messbar sind, erreicht.
• Gemäß verschiedenen Ausführungsformen besteht die Vorgehensweise darin, mehrere zyklische lineare (w, k, d) Codes über GF(2^w) zu konkatenieren, so dass die Konkatenation der Maskierungsabbildungen, welche wie oben beschrieben aus den dualen Abbildungen der jeweiligen Teil-Code-Wörter gebildet werden, untereinander als Code verträglich ist und die Minimaldistanz der jeweils anderen Teil-Codes nicht reduziert. Nach Konstruktion ist das auf diese Weise gebildete Maskierungsschema direkt homomorph mit der XOR-Operation und bis zu d-1 maskierte Daten- und Zufallsbits verraten keine Information über die maskiert gespeicherten Daten.
• Werden maskierte Daten zyklisch geschoben, so ist die Schiebe-Operation ebenfalls nach Konstruktion mit den jeweiligen, aus den zyklischen Code-Wörtern gebildeten Teilmasken bereits homomorph. Lediglich an den Übergangsstellen zwischen den Teilmasken (entsprechend den Übergangsstellen zwischen Blöcken von Codewörtern der konkatenierten Codes) können Fehler auftreten und die Maskierung des geschobenen Ergebnisses muss an diesen Übergangsstellen entsprechend korrigiert werden. Dazu ist aber nur ein Bruchteil des Aufwandes zur vollständigen Berechnung der Maskenbits des gesamten maskierten Datums notwendig. Und die benötigten Korrekturwerte sind vorab bekannte Funktionen der verwendeten Codes.
• Diese Herangehensweise ermöglicht Folgendes:
• • Die Masken zur Maskierung von Langzahlen können on-the-fly aus relativ kurzen Zufallsvektoren berechnet werden. Dadurch wird der Speicherbedarf zur Speicherung der maskierten Langzahlen im Vergleich zu der oben beschriebenen, einfachen Maskierungsmethode deutlich reduziert.
• • Die zur Konstruktion der Maskierungsfunktionen verwendeten Teil-Codes sind nach Konstruktion homomorph mit der XOR-Operation und auf den jeweiligen Teil-Masken auch homomorph bezüglich Schiebe-Operationen.
• • Die Konstruktion stellt sicher, dass das Maskierungsschema mit geringem Zusatzaufwand (an Flächenbedarf und Gatterkomplexität) zu einem bezüglich Schiebe-Operationen homomorphen Verfahren erweitert werden kann. Der zusätzliche Flächenbedarf und die zusätzliche Leistungsaufnahme der resultierenden Schaltung betragen nur einen Bruchteil des zur Berechnung des gesamten Maskierungsmusters notwendigen Aufwands.
• Zur Verdeutlichung wird im Folgenden ein Beispiel eines Maskierungsschemas gemäß einem Ausführungsbeispiel angegeben, welches aus einem 20 Bit Zufallsstring eine 60 Bit Maske erzeugt. Dabei hat die Maske die Eigenschaft, dass ein Angreifer mindestens 5 Bits aus der Menge der maskierten Daten-Bits und/oder des verwendeten Zufallsstrings kennen muss, um ein einzelnes maskiertes Daten-Bit zu erlernen. (Das bedeutet, dass der zugehörige duale Code die Minimaldistanz 5 besitzt.)
• Dazu wird die die folgende {0, 1} ^{20 × 60} Matrix M definiert:

  10000000000000010111	10000000000001100011	10000100000010000011
  11000000000000001011	11000000000000110001	11000010000001000001
  11100000000000000101	11100000000000011000	11100001000000100000
  11110000000000000010	01110000000000001100	01110000100000010000
  01111000000000000001	00111000000000000110	00111000010000001000
  10111100000000000000	00011100000000000011	00011100001000000100
  01011110000000000000	10001110000000000001	00001110000100000010
  00101111000000000000	11000111000000000000	00000111000010000001
  00010111100000000000	01100011100000000000	10000011100001000000
  00001011110000000000	00110001110000000000	01000001110000100000
  00000101111000000000	00011000111000000000	00100000111000010000
  00000010111100000000	00001100011100000000	00010000011100001000
  00000001011110000000	00000110001110000000	00001000001110000100
  00000000101111000000	00000011000111000000	00000100000111000010
  00000000010111100000	00000001100011100000	00000010000011100001
  00000000001011110000	00000000110001110000	10000001000001110000
  00000000000101111000	00000000011000111000	01000000100000111000
  00000000000010111100	00000000001100011100	00100000010000011100
  00000000000001011110	00000000000110001110	00010000001000001110
  00000000000000101111	00000000000011000111	00001000000100000111

• Es ist erkennbar, dass M aus der Konkatenation von 3 Blöcken aus je 20 zyklischen Schiebeoperationen von Wörtern aus {0, 1}²⁰ gebildet wurde. In jedem Teilblock bilden die Spalten der Matrix Code-Wörter eines Codes mit der Minimaldistanz 5. Außerdem wurden die Blöcke so gewählt, dass diese Eigenschaft für alle 60 Spalten der Matrix M erhalten bleibt. Daraus folgt insbesondere, dass jeweils bis zu 4 Spalten aus M über GF(2) linear unabhängig sind.
• Zum Maskieren eines zu maskierenden Datenworts w ∈ {0, 1}⁶⁰ wird folgendes durchgeführt:
1. 1) Erzeugen eines 20 Bit-Zufallsstrings r ∈_R {0, 1}²⁰
2. 2) Berechnen durch Matrixmultiplikation der 60 Bit-Maske m = r * M
3. 3) Erzeugen des maskierten Datenworts f(w, r) := w' = w ⊕ m durch bitweise XOR-Verknüpfung mit der Maske.
• Im Speicher werden lediglich das maskierte Datenwort und der Zufallsstring (w', r) ∈ {0, 1}⁸⁰ abgespeichert.
• Seien f(w₁, r₁), f(w₂, r₂) ∈ {0, 1}⁸⁰ maskierte Datenwörter und bezeichne ROTL1(x) die zyklische Rotation eines Bit-Strings x um eine Stelle nach links. Dann gelten folgende Rechenregeln: $$\begin{array}{l}\text{f}\left({\text{w}}_1,{\text{ r}}_1\right)\oplus \text{f}\left({\text{w}}_2,{\text{ r}}_2\right)=\left({\text{w}}_1\oplus {\text{r}}_1*\text{M}\right)\oplus \left({\text{w}}_2\oplus {\text{r}}_2*\text{M}\right)\\ ={\text{w}}_1\oplus {\text{w}}_2\oplus \left({\text{r}}_1\oplus {\text{r}}_2\right)*\text{M}=\text{f}\left(\left({\text{w}}_1\oplus {\text{w}}_2\right),{\text{r}}_1\oplus {\text{r}}_2\right)\text{ und }\end{array}$$

  

  $$\text{f}\left(\text{ROTL1}\left({\text{w}}_1\right),\text{ROTL1}\left({\text{r}}_1\right)\right)=\text{ROTL1}\left(\text{f}\left({\text{w}}_1,{\text{r}}_1\right)\right)+{\text{r}}_1*{\text{E}}_{\text{L}},$$

  

  wobei die Korrekturabbildung E_L für das Rechenbeispiel durch die folgende {0, 1}^{20 × 60} Matrix gegeben ist:

  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000001	00000000000000000000	00000000000000000001
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000001	00000000000000000000	00000000000000000001
  00000000000000000001	00000000000000000001	00000000000000000000
  00000000000000000001	00000000000000000001	00000000000000000000
  00000000000000000000	00000000000000000001	00000000000000000001
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000001	00000000000000000001
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000
  00000000000000000000	00000000000000000000	00000000000000000000

• Es folgt direkt aus der Konstruktion des Maskierungsverfahrens, dass die Matrix E_L nur an den (rechten Rändern der) Übergangsstellen zwischen den Blöcken aus zyklischen Teil-Codes von 0 verschiedene Einträge haben kann.
• Alle verwendeten Matrixmultiplikationen können durch kombinatorische Schaltungen mit geringer Tiefe aus XOR-Gattern realisiert werden.
• Basierend auf den obigen Rechenregeln R1 und R2 kann ein vollständig maskiert arbeitender Multiplizierer für Langzahlen über einem endlichen Körper GF(2⁶⁰) konstruiert werden. Dazu werden gemäß einer Ausführungsform folgende weitere Hardware-Komponenten verwendet:
• • Für eine sichere Implementierung eines GF(2ⁿ) Multiplizierers wird die Maskierung von Operanden und Zwischenergebnissen während verschiedener Arbeitsschritte mit neuen Zufallszahlen aufgefrischt. Dabei sollte die Vertraulichkeit der maskierten Daten natürlich nicht gefährdet werden. Um die Maskierung einer gespeicherten Langzahl (w₁', r₁) mit neuen Zufalls-Bits aufzufrischen, wird zunächst ein neuer Zufallsstring s erzeugt. Die maskiert gespeicherte Langzahl wird dann durch den Wert f(v₁, r₁ ⊕ s) = w₁' ⊕ s * M ersetzt. Dabei werden zu keinem Zeitpunkt der Auffrischung nicht maskierte Bits der Langzahl berechnet oder verwendet.
• • Wenn der Inhalt des Akkumulators während der Durchführung einer Multiplikation geschoben wird, werden neben der Rotation weitere Bits in Abhängigkeit vom aktuellen Wert des MSBs (höchstwertigen Bits) verändert. Dieser modulare Reduktionsschritt hängt bei einer Polynomialdarstellung der Körperelemente aus GF(2ⁿ) von einem irreduziblen Polynom p(x) ∈ GF(2)[x] vom Grad n ab, welches die konkrete Darstellung der Körperelemente als Koeffizientenvektoren eines Vektorraums der Dimension n über GF(2) festlegt. Durch die Rückkoppelung des maskierten Werts des höchstwertigen Bits an weitere Bit-Positionen gemäß p(x) werden die Maskierungen verschiedener Bits miteinander verknüpft und müssen anschließend durch geeignete Korrekturterme angepasst werden, um eine korrekt maskierte Darstellung des Ergebnisses zu erhalten. Eventuell kann durch diesen Schritt die Minimaldistanz des für die Konstruktion der Maskierungsmatrix M verwendeten dualen Codes reduziert werden. Um eine solche Reduktion der Minimaldistanz zu verhindern, kann das Zwischenergebnis der Rotation mit neuen Zufallszahlen aufgefrischt werden oder die Minimaldistanz des verwendeten dualen Codes geeignet erhöht werden.
• • In Abhängigkeit von einem Bit des seriell verarbeiteten Operanden werden Partialprodukte des parallel verarbeiteten Operanden berechnet und zum aktuellen Inhalt des Akkumulators addiert. Um die Vertraulichkeit der Operanden nicht zu gefährden, werden diese maskiert gespeichert und auch die berechneten Partialprodukte müssen geeignet maskiert werden. Bei einem Multiplizierer über GF(2ⁿ) besteht die Berechnung der Partialprodukte aus einer bitweisen UND Verknüpfung des parallelen Operanden mit dem aktuell verarbeiteten Bit des seriellen Operanden. Zur sicheren Implementierung dieser UND Operationen können beispielsweise Threshold-Implementation Techniken verwendet werden, welche auch zur seitenkanalresistenten Implementierung von symmetrischen Verschlüsselungsfunktionen zum Einsatz kommen. Eine Schaltung analog zum Trichina-UND-Gatter ermöglicht eine vertrauliche Berechnung einer UND-Verknüpfung von in Shares vorliegenden booleschen Werten.
• Analog zu dem oben beschriebenen Konstruktionsverfahren lässt sich eine Korrekturabbildung E_R für die zyklische Rotation ROTR1(x) eines Bit-Strings x um eine Stelle nach rechts konstruieren. Auch für die Korrekturabbildung E_R gilt, dass die zugehörige Matrix nur an den (linken Rändern der) Übergangsstellen zwischen den Blöcken aus zyklischen Teil-Codes von 0 verschiedene Einträge haben kann.
• In einem Ausführungsbeispiel werden die Teilblöcke der Maskierungsmatrix M so gewählt, dass die Summe der Summanden in den Spalten der Korrekturabbildungen E_L und/oder E_R minimal ist. Das heißt, dass das Hamming-Gewicht der Matrizen der Korrekturabbildungen E_L und/oder E_R minimiert wird.
• In einem weiteren Ausführungsbeispiel werden die Teilblöcke der Maskierungsmatrix M so gewählt, dass die maximale Anzahl der Summanden in den jeweiligen Spalten der Korrekturabbildungen E_L und/oder E_R minimal ist.
• Im Folgenden wird ein Ausführungsbeispiel eines maskierten seriell-parallel Multiplizierers, beispielsweise zur Realisierung einer an ein Registerarray gekoppelten Recheneinheit zur Implementierung von kryptographischen Verfahren über binären elliptischen Kurven, beschrieben.
• Eine elliptische Kurve kann über einem binären Erweiterungskörper GF(2ⁿ) = F_{2 n} definiert werden (auch bekannt als binärer Körper oder Körper der Charakteristik 2), der durch ein Grad-n-Polynom f(x), das über GF(2) irreduzibel ist, als GF(2ⁿ) = F₂[x]/(f(x)) definiert werden kann.
• Ein Element a(z) ∈ GF(2ⁿ) kann als Polynom mit maximalem Grad n-1 mit binären Koeffizienten dargestellt werden. Addition von Körperelementen ist die Addition von binären Polynomen und Multiplikation erfolgt modulo f(x). Ein Körperelement a(x) = a_n-1x^n-1 + ... + a₁x + a_o ∈ F_{2 n} entspricht einem Vektor a = (a_n-1, ..., a₁, a₀). Die Addition in F_{2 n} ist lediglich die XOR-Operation, die auf die entsprechenden zwei Vektoren angewendet wird (es findet keine Übertragspropagation statt, wie es bei elliptischen Kurven über GF(p) der Fall wäre). Für die Multiplikation kann die Schiebe- und-Addiere-Methode verwendet werden. Die Notation b(j) oder die alternative Notation b_j wird verwendet, um den Zugriff auf das Bit j des n-Bit-Vektors b zu bezeichnen.
• 2 veranschaulicht eine Realisierung einer Multiplikation in Hardware.
• Sie weist eine ALU (Arithmetic Logic Unit) 200 auf, die Körperadditionen und Körpermultiplikationen ausführen kann. Die ALU 200 weist eine Steuerlogik 205 und ein Akkumulationsregister (Accu) 201 von n Bits auf, das mit einer Registerbank 202 verbunden ist, die eine bestimmte Anzahl von Operanden von n Bits in Operandenregistern 203, 204 und 206 enthält. Die Adresse, die an die Registerbank angelegt wird, wird so gewählt, dass auf zwei Operanden a, b ∈ GF(2ⁿ) von der ALU 200 zugegriffen werden kann. Der Einfachheit halber kann angenommen werden, dass die Registerbank 202 den Zugriff auf einen vollen n-Bit breiten Operanden a und auf ein Bit des n-Bit breiten Operanden b erlaubt. Die grundlegenden Operationen, die von der ALU ausgeführt werden, sind wie folgt:
1. a) Laden eines Wertes in das Akkumulationsregister Accu 201 aus der Registerbank 202 und Zurückschreiben.
2. b) Verschieben des Werts im Accu 201 nach links ohne modulare Reduktion durch f(x).
3. c) Verschieben des Werts im Accu 201 nach links mit modularer Reduktion durch f (x). Dies entspricht einer Multiplikation mit der Unbestimmten x.
4. d) Addition (d.h. XOR) eines Operanden zu dem Wert im Accu 201.
5. e) Multiplikation von zwei Operanden a, b ∈ F₂m so, dass Accu = ab mod f(x). Dies kann unter Verwendung des Links-nach-Rechts-Schiebe-und-Addiere-Algorithmus implementiert werden: Setze Accu = (Accu<<1) XOR b_i*a mod f(x) für i von n-1 bis 0.
• Um die Körpermultiplikation zu unterstützen, unterstützen die ALU 200 und die zugehörige Steuerlogik 205 eine Operation, die den Accu 201 mit Null initialisiert und dann für n Zyklen den Inhalt des Accus 201 nach links durch f (x) reduziert schiebt und abhängig von einem ausgewählten Bit b_i des Operanden b der volle Operand a zum Inhalt des Accus 201 addiert wird. Dies ist eine Kombination der zuvor beschriebenen Grundoperationen.
• Um Elliptische-Kurven-Kryptographie (ECC) durchzuführen, führt die Steuerlogik (Zustandsautomat) 205 eine gegebene Folge von Additionen und Multiplikationen aus und stellt die korrekten Adressen der Operanden der Registerbank 202 bereit (um die korrekten Operanden zu laden und zu speichern; beispielsweise Verwenden der richtigen Additionsformeln für den Verdopple-und-Addiere-Algorithmus oder den Montgomery-Ladder-Algorithmus) und schreibt das Endergebnis im Accu 201 an die richtige Position in die Registerbank 202. Dafür kann die Registerbank 202 auch zusätzliche temporäre Daten in einem oder mehreren weiteren Registern 206 enthalten, auf die während einer einzelnen Multiplikation nicht zugegriffen wird, die jedoch für die Implementierung der Additionsformeln der elliptischen Kurvenpunkte benötigt werden.
• Ein typisches Problem ist, dass ein Angreifer, der in der Lage ist, Werte von einer Leitung, die zu dem Operandenregister 203 führt, das den Operanden b speichert, (z.B. hinter einem Multiplexer des Operandenregisters 203), zu lesen, den ganzen Wert von b auslesen kann, da bei der Multiplikation b normalerweise sequentiell (aufgrund des linksnach-rechts-Multiplikationsalgorithmus) abgerufen wird.
• 3 zeigt eine maskierte ALU 300, die zur Maskierung einen Code mit Minimaldistanz d verwendet. Daher ist es für diese Implementierung erforderlich, dass ein Angreifer mindestens d Leitungen beobachtet, um eine sinnvolle Information über die verwendeten Operanden abzuleiten. Es wird jedoch angemerkt, dass die maskierte ALU keine Informationen des Steuerflusses schützt (z. B. Adressen von Operanden oder die Abfolge von mathematischen Operationen).
• Wie die ALU 200 weist die ALU 300 einen Accu 301, eine Steuerlogik (nicht gezeigt) und eine Registerbank mit Operandenregistern 303, 304 auf.
• Das Operandenregister 304 für den Wert b wird sequentiell ausgelesen (es wird zu jedem Zeitpunkt nur auf ein Bit zugegriffen).
• Auf das Operandenregister 303 für den Wert n-Bit Wert a erfolgt voller (d.h. n-Bitbreiter) Zugriff.
• In der obigen Notation wurde ein Zufallsvektor r ε_R {0, 1}¹ der Länge 1 gewählt und r wurde zum Maskieren des Inhalts eines Registers der Länge n verwendet. Die zugehörige Matrix M besteht aus der Konkatenation von zyklischen Code-Matrizen der Dimension 1 x1.
• Die Länge l eines Zufallswerts ist kürzer als die Länge eines Operanden (und Operandenregisters) der Länge n. Ein Wert wird unter Verwendung einer abgeleiteten Maske x' = r * M der Länge n maskiert.
• Im Allgemeinen werden alle Variablen nur maskiert gespeichert (im Accu 301 und in der Registerbank) und auf maskierte Weise verarbeitet und Operationen werden auf eine solche Weise durchgeführt, dass der Wert nach einer Operation korrekt demaskiert werden kann.
• Im Allgemeinen ist während einer Berechnung die Maskierung für jede Operation vorhanden und nur wenn ein Ergebnis und somit nicht sicherheitsrelevante Daten den Krypto-Kern verlassen wird die Maskierung entfernt.
• Gegenüber der ALU 200 sind in der ALU 300 jedes Register 303, 304 in der Registerbank und das Akkumulationsregister Accu 301 durch Maskenregister 305, 306, 307 erweitert, um einen zusätzlichen 1-Bit-String zu speichern, der verwendet wird, um eine Maske für einen n-Bit-Datenwert abzuleiten.
• Auf das Maskenregister 306 für die Maske am von a erfolgt voller (1-Bit breiter) Zugriff.
• In dem Maskenregister 305 für die Maske b_m von b wird auf das Bit der Maske b_m*M zugegriffen, welches zu dem Bit des Operanden b gehört, auf das aktuell zugegriffen wird. Die Maskenregister 305, 306 für die Masken, die zu den Operandenregistern 303, 304 gehören, können auch Teil der Registerbank sein, die zusätzlichen Speicherplatz für Masken enthalten kann.
• Um Register in der Registerbank zu bezeichnen, wird die Schreibweise r[i]* verwendet, um einen maskierten n-Bit-Wert zu bezeichnen, wobei i den Eintrag in der Registerbank spezifiziert (z. B. i ∈ 0..9 für eine Registerbank, die 10 maskierte Werte und ihre Masken speichern kann). Die 1-Bit-Maske, die r[i]* entspricht, wird als r_m[i] bezeichnet. Der unmaskierte Wert r[i] kann somit durch Berechnen von r_m[i] *M XOR r[i]* erhalten werden. Das Akkumulationsregister 301 wird ebenfalls erweitert: Die ALU 300 enthält ein n-Bit-Register Accu 301 für die maskierten Daten und ein zugehöriges 1-Bit-Maskenregister Accu_m 307 für die entsprechende Maske.
• Die Operation (a), die Daten von der Registerbank an der Adresse i in das Akkumulationsregister Accu 301 lädt oder sie zurück in die Registerbank schreibt erfordert keine besonderen Maßnahmen: Ein maskierter Wert r[i]* und die entsprechende Maske r_m[i] werden aus der Registerbank in das Register Accu 301 und Accu_m 307 kopiert. Speichern ist das Kopieren der Daten in Accu bzw. Accu_m zurück nach r[i]* bzw. r_m[i].
• Es wird eine zusätzliche Operation (a1) angewendet, um einen von einer externen Entität (z. B. einer Abfrage) erzeugten Wert in die Registerbank zu speichern und sie zu maskieren oder ein unmaskiertes (plain) Ergebnis (z. B. eine Koordinate einer berechneten Antwort) auszugeben. Dies ist möglich, da jede Operation (b, c, d, e) die Beziehung für einen Operanden a und seine maskierte Repräsentation a' und die Maske x_a beibehält, für die gilt: a = a' XOR x_a * M. Somit kann eine Einheit, die Zugriff auf den maskierten Wert und die Maske hat, die Lade- und Speicheroperationen an der Registerbank ausführen, wo unmaskierte Daten zum Ausgangsport der Einheit kopiert werden oder wo unmaskierte Daten in der Registerbank maskiert gespeichert werden.
• Die Implementierung der XOR-Operation (d) ist aufgrund der Linearität unkompliziert. Zwei maskierte Werte a' = a XOR x_a' und b' = b XOR x'_b, die in der Registerbank als maskierte m-Bit-Werte a' = r[i]*, b' = r[j]* und 1-Bit-Maskenwerte x_a = r_m[i], x_b = r_m[j] gespeichert sind, werden durch Berechnung von Accu = c' = a' XOR b' (maskierter Wert) und Accu_m = x_c = x_a XOR x_b (Masken) unabhängig verknüpft. Im Allgemeinen bedeutet dies, einen Operanden in Accu bzw. Accu_m zu laden und dann den anderen Operanden mittels XOR mit Accu bzw. Accu_m zu kombinieren und das Ergebnis zurück in die Registerbank zu schreiben. Die Maske x'_c kann von c' entfernt werden durch: $$\text{c}\text{'}{\text{ XOR x}}_{\text{x}}\ast \text{M}=\text{a XOR b}=\text{c}.$$

  
• Für die Ein-Position-Schiebevorgänge (b) ist nicht viel zusätzliche Logik erforderlich. Angenommen, ein maskierter Operand wurde in Accu 301 und seine Maske in Accu_m 307 geladen (wie für Operation (a) beschrieben). Ein nahezu korrektes Ergebnis kann erhalten werden, indem Accu 301 um eine Position nach links verschoben wird und Accu_m um eine Position nach links rotiert wird. Dies erfolgt in dem Maskenregister 307. An den Übergangsstellen zwischen den zyklischen Teil-Codes sind Korrekturen der verwendeten Masken notwendig.
• Wenn eine Links-Schiebe-Operation zusammen mit einer Reduktion modulo f(x) (Operation (c)) berechnet wird, wird die Maskierung berücksichtigt. Eine effiziente Weise zum Implementieren der modularen Reduktion für nicht-maskierte Implementierungen, wenn f(x) = xⁿ + x^γ + x^β + x^α + 1 und der n+1-Bit-Operand in dem Accu 301 gegeben ist, ist es, bedingt eine modulare Reduktion durchzuführen, wenn Accu(n) = 1 ist, indem die Bits in f(x) gesetzten Bits gesetzt bzw. XOR-verarbeitet werden: Accu(n) = 0, Accu(γ) = Accu(γ) XOR 1, Accu(β) = Accu(β) XOR 1, Accu(α) = Accu(α) XOR 1, Accu(0) = Accu(0) XOR 1.
• Dies kann weiter vereinfacht werden, indem immer, bei jedem Nach-Links-Schieben, wobei Accu(n) nicht notwendigerweise gespeichert ist sondern auch on- the-fly beim Schieben erzeugt werden kann, berechnet wird: Accu(γ) = Accu(γ) XOR Accu(n), Accu(β) = Accu(β) XOR Accu(n), Accu(α) = Accu(α)XOR Accu(n), Accu(0) = Accu(0)XOR Accu(n), Accu(n) = 0.
• Für die korrekte Funktionalität muss die Beziehung zwischen den maskierten Daten und der Maske beibehalten werden. Logisch muss eine Reduktion durchgeführt werden, wenn Accu(n) XOR Accu_m(n mod l) = 1, da dies der demaskierte logische Wert ist (es sollte beachtet werden, dass in diesem Zusammenhang die Variable n zwei unterschiedliche Bedeutungen hat).
• Das Demaskieren kann jedoch zu einer Sicherheitslücke führen, da die Daten im Klartext (unmaskiert) verarbeitet werden. Deshalb kann auf der maskierten ALU 300 die modulare Reduktion modulo f(x) = x^m + x^γ + x^β + x^α + 1 berechnet werden (integriert in das Verschieben nach links) als: Accu(γ) = $$\begin{array}{l}\text{Accu}\left(\mathrm{\gamma }\right)\text{XOR Accu}\left(\text{n}\right){\text{XOR Accu}}_{\text{m}}\left(\text{n mod l}\right),\text{ Accu}\left(\mathrm{\beta }\right)=\\ \text{Accu}\left(\mathrm{\beta }\right)\text{XOR Accu}\left(\text{n}\right){\text{XOR ALU}}_{\text{m}}\left(\text{n mod l}\right),\text{ ALU}\left(\mathrm{\alpha }\right)=\\ \text{Accu}\left(\mathrm{\alpha }\right)\text{XOR Accu}\left(\text{n}\right){\text{XOR Accu}}_{\text{m}}\left(\text{n mod l}\right),\text{ Accu}\left(0\right)=\\ \text{Accu}\left(0\right)\text{XOR Accu}\left(\text{n}\right){\text{XOR Accu}}_{\text{m}}\left(\text{n mod l}\right),\text{ Accu}\left(\text{n}\right)=0.\end{array}$$

  
• Idealerweise werden die beiden XORs bei Accu(n) und Accu_m(n mod l) auf eine Weise angeordnet, das kein Signal Klartext trägt, indem dazwischen ein frischer Zufallswert addiert wird.
• Eine Multiplikation modulo f(x) im endlichen Körper (Operation (e)) verwendet die zuvor beschriebenen funktionalen Blöcke.
• Die Linksverschiebung und die Reduktion in der Schleife von Operation (e) kann unter Verwendung der für Operation (c) beschriebenen Herangehensweise realisiert werden. Jedoch muss die bedingte parallele Addition des Operanden a abhängig von dem Wert des seriell ausgelesenen Operanden b(j) unter Berücksichtigung der Maskierung ausgeführt werden. Auf der Klartext- ALU 200 besteht diese Operation darin Accu(i) = Accu(i) XOR (b(j) AND a(i)) für i von 0 bis n-1 in jeder Iteration der Hauptschleife (d.h. der Schleife über die Stellen des Operanden b, j von n-1 bis 0) zu setzen, wobei das „falls“ als UND-Gatter 207 realisiert wird (Wert a wird nur XOR-verarbeitet falls b(j)=1).
• Für die maskierte ALU 300 wird auf zwei maskierte Operanden zur Multiplikation a' = a XOR x_a' und b' = b XOR x'_b Bezug genommen, die in der Register-Datei als maskierte n-Bit-Werte a' = r[i]*, b' = r[j]* und 1-Bit-Maskenwerte x_a = r_m[i], x_b = r_m[j] gespeichert sind.
• Eine Option ist es, b(j)_plain = b'(j) XOR x_b(j mod l) zu berechnen und dann die Addition auszuführen, falls b(j)_plain = 1. Dies würde jedoch zu Operationen in Klartext führen.
• Um eine sichere bedingte Addition von a', x_a zu Accu bzw. Accu_m abhängige von dem Wert von b'(j) und x_b(j mod l) in der Iteration j ∈ n - 1 to 0 zu erreichen, wird ein maskiertes und randomisiertes UND-Gatter für die parallele Addition kombiniert mit einer Maskenaktualisierung (bzw. Auffrischung) unter Verwendung von zufälligen oder pseudozufälligen Bits verwendet. Das maskierte UND-Gatter ähnelt einem maskierten Trichina-UND-Gatter. Die bedingte Addition von Operand a wird separat auf den maskierten Daten und auf der Maske durchgeführt. Dies erfolgt durch ein maskiertes UND (Operand) 308 und ein maskiertes UND (Maske) 309.
• Das maskierte UND (Operand) 308 addiert abhängig von dem ausgelesenen Bit des Operands B und dem Maskenbit den Operanden a. Die Addition ist durch 1-Bits eines Zufallszahlengenerators 310 randomisiert. Die Auswahl von Partialprodukten ist damit geschützt.
• Die Addition des Partialprodukts erfolgt durch ein erstes XOR 310 und die Addition der neu erzeugten Maske durch ein zweites XOR 311.
• Zur Realisierung der Maskierten-UND-Operationen 308, 309 kann die in 4 dargestellte Schaltung verwendet werden.
• 4 zeigt ein Gatter 400 zum Implementieren einer maskierten UND-Verknüpfung.
• Die maskierte UND-Verknüpfung instanziiert für den Accu 301 n Instanzen eines einzelnen maskierten UND-Gatters für i von 0 bis n-1. Das Bit b (j) wird durch die Steuerlogik (Zustandsmaschine) für j von n-1 bis 0 ausgewählt. Zusätzlich wird das Gatter 400 für Accu_m 1-mal wiederholt, wobei Zugriffe auf b und a durch Zugriffe auf b_m und a_m ersetzt werden.
• Das Gatter 400 weist zwei UND-Gatter 401, 402 und zwei XOR-Gatter 403, 404 auf und berechnet $$\begin{array}{l}\text{u}\left(\text{i}\right)=\left(\text{b}\left(\text{j}\right)\text{AND a}\left(\text{i}\right)\right)\text{XOR}\left(\left({\text{b}}_{\text{m}}\left(\text{j}\right)\text{XOR a}\left(\text{i}\right)\right)\text{XOR r}\left(\text{i mod l}\right)\right)=\\ \left(\text{b}\left(\text{j}\right){\text{XOR b}}_{\text{m}}\left(\text{j}\right)\right)\text{AND a}\left(\text{i}\right)\text{XOR r}\left(\text{i mod l}\right),\end{array}$$

  

  für die Eingänge des ersten UND-Gatters 401, das mit dem XOR 311 verbunden ist und $${\text{u}}_{\text{m}}\left(\text{i}\right)=\left({\text{b}}_{\text{m}}\left(\text{j}\right){\text{AND a}}_m\left(\text{i}\right)\right)\text{XOR}\left(\left({\text{b}}_{\text{m}}\left(\text{j}\right){\text{XOR a}}_{\text{m}}\left(\text{i}\right)\right)\text{XOR r}\left(\text{i mod l}\right)\right),$$

  

  für die Eingänge des zweiten UND-Gatters 402, das mit ACC_m(i) 307 verbunden ist.
• Somit wird in der ALU 300 $$\text{Accu}\left(\text{i}\right)=\text{Accu}\left(\text{i}\right)\text{XOR u}\left(\text{i}\right){\text{ und Accu}}_m\left(\text{i}\right)={\text{Accu}}_{\text{m}}\left(\text{i}\right){\text{XOR u}}_{\text{m}}\left(\text{i}\right)$$

  

  berechnet. Das Gatter 400 führt die beabsichtigte Logik-Funktion für b(j) AND a(i) (für a, b in Klartext) auf geschützte Weise aus. Dabei sollte das maskierte UND-Gatter so gewählt werden, dass auch hier das Sicherheitslevel gegen Angriffe dem Sicherheitslevel der Maskierung angepasst ist.
• Außerdem ist eine Korrekturschaltung 312 vorgesehen (vgl. Korrekturabbildung E_L). Diese erhält l bits aus Accu_m 307. Die Ausgänge der Korrekturschaltung 312 sind mit XORs 313, 314, 315, 316 verbunden, an den die Korrekturschaltung 312 ein Korrekturbit liefert. Mittels seinen anderen Eingangs erhalten die XORs 313, 314, 315, 316 das zu korrigierende Bit des Accu 301. Das Ergebnis der XORs 313, 314, 315, 316 ist die durch die Korrekturschaltung 312 durchgeführten Korrektur und wird wieder dem Accu 301 zugeführt.
• Eine zusätzliche Sicherheitsmaßnahme ist es, ein zufälliges Bit r zu dem seriell ausgelesenen Bit des maskierten Operanden b(j) und seiner Maske b_m(j) zu addieren. Da das zufällige Bit zu beiden Shares addiert wird, beeinflusst es nicht die Korrektheit der Berechnung.
• Die maskierte ALU (und ein entsprechendes Rechenwerk, das die maskierte ALU enthält) kann unabhängig und/oder ergänzend zu anderen Sicherheitsmechanismen in Kryptographieanwendungen, z.B. basierend auf elliptischen Kurven, angewendet werden. Insbesondere beeinflussen Randomisierungs- oder Blendungs-Gegenmaßnahmen wie eine randomisierte Darstellung elliptischer Kurvenpunkte in projektiven Koordinaten nicht die maskierte ALU.
• Zusammenfassend wird gemäß verschiedenen Ausführungsformen ein Rechenwerk bereitgestellt, wie es in 5 dargestellt ist.
• 5 zeigt ein Rechenwerk 500 gemäß einer Ausführungsform.
• Das Rechenwerk 500 weist eine Maskenerzeugungsschaltung 501 auf, die eingerichtet ist, eine Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes zu erzeugen.
• Das Rechenwerk 500 weist außerdem eine Maskierungsschaltung 502 auf, die eingerichtet ist, zu verarbeitende Daten mittels der Maske zu maskieren.
• Ferner weist das Rechenwerk 500 eine arithmetisch-logische Einheit 503 auf, die eingerichtet ist, die maskierten Daten mittels Additionen und Rotationen zu verarbeiten.
• In anderen Worten wird gemäß einer Ausführungsform ein Maskierungsvektor basierend auf einer Konkatenation von Codewort-Blöcken (Codewort-Matrizen) von zwei oder mehr unterschiedlichen zyklischen Codes erzeugt.
• Die Codewörter der verschiedenen zyklischen Codes gehen durch Verschiebung auseinander hervor. In anderen Worten könnten für jeden der zyklischen Codes alle Codewörter erzeugt werden, indem ein beliebiges Codewort des Codes ausgewählt wird und zyklisch Bit für Bit verschoben wird, wobei nach jeder 1-Bit-Verschiebung ein neues Codewort entsteht.
• Die Codes sind unterschiedlich insofern, dass sie sich in mindestens einem oder auch in mehreren oder allen Codewörtern unterscheiden.
• Jeder der Codes hat mindestens eine vorgegebene minimale Hamming-Distanz und die Codes untereinander haben ebenfalls mindestens die vorgegebene minimale Hamming-Distanz.
• Der Maskenerzeugungsvektor hat gemäß einer Ausführungsform die Länge eines Codeworts. Je mehr Blöcke von Codes verwendet werden, umso kleiner ist der Maskenerzeugungsvektor im Vergleich zum erzeugten Maskierungsvektor. Auf diese Weise ist der Speicherbedarf für die Maske (gegenüber der Verwendung eines vollen Maskierungsvektors) erheblich reduziert.
• Insbesondere ermöglicht die Herangehensweise von 5 eine flächenoptimierte Implementierung eines vollständig maskiert arbeitenden Multiplizierers für Langzahlen über endlichen Körpern GF(2ⁿ).
• Die Verarbeitung der Daten kann eine Multiplikation von zwei Operanden aufweisen, bei der die beiden Operanden mittels einer maskierten UND-Verknüpfung kombiniert werden. Dabei kann jeder UND-Verknüpfung die Maske (z.B. ein Maskenbit) aufgefrischt werden. In der Ausführungsform von 3 geht beispielsweise in die maskierten UND-Verknüpfungen 308, 309 Zufallsinformation aus dem RNG 310 ein. Dadurch werden die Inhalte von Accu 301 und Accu_m immer wieder neu basierend auf Zufallswerten maskiert.
• Der Maskierungsmechanismus gemäß 5 erfordert gegenüber einem n-aus-n-Secret-Sharing-Scheme einen geringeren Hardwareaufwand, da keine n-fache Berechnung und Speicherung der benötigten Langzahlen und Zwischenergebnisse notwendig ist. Die Maskierung gemäß 5 kann mit deutlich weniger Hardwareaufwand (und dadurch mit reduziertem Energieverbrauch) oder bei einer Softwareimplementierung mit deutlich weniger Rechenoperationen und Speicherverbrauch realisiert werden. Somit kann effizient die Sicherheit von vertraulichen Daten gegen Angriffe gewährleistet werden. In diesem Zusammenhang ist anzumerken, dass anstelle einer Realisierung mittels dedizierter Hardwarekomponenten auch eine Realisierung in Software auf einem Mikrocontroller oder einer CPU (z.B. einer Chipkarte) möglich ist.
• In Matrixform geschrieben wird der Maskierungsvektor durch Linksmultiplikation des Maskenerzeugungsvektors mit einer Matrix erzeugt, wobei die Matrix einer Konkatenation von Submatrizen entspricht, wobei jede Submatrix einem der Codes entspricht und aus Spalten besteht, wobei jede Spalte ein Codewort des Codes ist, wobei außerdem die Codewörter (d.h. Spalten) in der Submatrix derart angeordnet sind, dass zwei benachbarte Codewörter (Spalten) durch eine zyklische 1-Bit-Verschiebung auseinander hervorgehen. In anderen Worten sind in einer Submatrix die Codewörter des Codes in ihrer Reihenfolge aufgeschrieben, wie sie sich durch die Erzeugung der Codewörter durch zyklisches Verschieben eines der Codewörter nacheinander ergeben.
• Die Daten werden beispielsweise im Rahmen einer kryptographischen Operation verarbeitet, beispielsweise für eine Entschlüsselung, Verschlüsselung, Signaturberechnung, Response-Berechnung für ein Challenge-Response-Verfahren etc.
• 6 zeigt ein Flussdiagram 600, das ein Verfahren zum Rechnen mit maskierten Daten gemäß einer Ausführungsform veranschaulicht.
• In 601 wird eine Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes erzeugt.
• In 602 werden zu verarbeitender Daten mittels der Maske maskiert.
• In 603 werden die maskierten Daten mittels Additionen und Rotationen verarbeitet.
• Im Folgenden werden Ausführungsbeispiele angegeben.
• Ausführungsbeispiel 1 ist ein Rechenwerk wie mit Bezug auf 5 beschrieben.
• Ausführungsbeispiel 2 ist ein Rechenwerk gemäß Ausführungsbeispiel 1, wobei die arithmetisch-logische Einheit ein Akkumulationsschieberegister zum Verarbeiten der maskierten Daten aufweist.
• Ausführungsbeispiel 3 ist ein Rechenwerk gemäß Ausführungsbeispiel 1 oder 2, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und die arithmetisch-logische Einheit eingerichtet ist, den ersten Operanden und den zweiten Operanden zu rotieren, zu addieren oder beides.
• Ausführungsbeispiel 4 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 3, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und die arithmetisch-logische Einheit eingerichtet ist, den ersten Operanden und den zweiten Operanden zu multiplizieren.
• Ausführungsbeispiel 5 ist ein Rechenwerk gemäß Ausführungsbeispiel 4, aufweisend eine maskierte Auswahlschaltung, die zur Realisierung der Multiplikation eine maskierte UND-Verknüpfung des ersten Operanden und zweiten Operanden durchführt.
• Ausführungsbeispiel 6 ist ein Rechenwerk gemäß Ausführungsbeispiel 5, wobei die maskierte Auswahlschaltung eingerichtet ist, die Maskierung der zu verarbeitenden Daten bei der maskierten UND-Verknüpfung aufzufrischen.
• Ausführungsbeispiel 7 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 4 bis 6, wobei die Multiplikation eine Multiplikation über einem endlichen Körper GF(2ⁿ) ist.
• Ausführungsbeispiel 8 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 7, wobei jeder Block von Codewörtern aus den Codewörtern eines der zyklischen Codes besteht.
• Ausführungsbeispiel 9 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 8, aufweisend eine Korrekturschaltung die eingerichtet, durch Inhomogenität zwischen den Blöcken von Codewörtern entstehende Fehler zu korrigieren.
• Ausführungsbeispiel 10 ist ein Rechenwerk gemäß Ausführungsbeispiel 9, wobei die Korrekturschaltung eingerichtet ist, die durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehenden Fehler zu korrigieren.
• Ausführungsbeispiel 11 ist ein Rechenwerk gemäß Ausführungsbeispiel 9 oder 10, wobei die Korrekturschaltung eingerichtet ist, die durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehende mangelnde Homomorphie der Maskierung bezüglich der Verschiebung von Daten zu korrigieren.
• Ausführungsbeispiel 12 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 11, wobei alle Codes dieselbe Codewortlänge haben und die Codewortlänge gleich der Länge des Maskenerzeugungsvektors ist.
• Ausführungsbeispiel 13 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 12, wobei das Rechenwerk eingerichtet ist, die Daten zur Durchführung einer kryptographischen Operation zu verarbeiten.
• Ausführungsbeispiel 14 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 13, wobei die Daten eine Signatur, einen kryptographischen Schlüssel, zu verschlüsselnde Daten und/oder zu entschlüsselnde Daten repräsentieren.
• Ausführungsbeispiel 15 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 14, wobei der Maskenerzeugungsvektor ein zufällig erzeugter Vektor ist.
• Ausführungsbeispiel 16 ist ein Rechenwerk gemäß einem der Ausführungsbeispiele 1 bis 15, wobei die mehreren zyklischen Codes unterschiedlich sind.
• Ausführungsbeispiel 17 ist ein Verfahren zum Rechnen mit maskierten Daten wie mit Bezug auf 6 beschrieben.
• Ausführungsbeispiel 18 ist ein Verfahren gemäß Ausführungsbeispiel 17, aufweisend das Verarbeiten der maskierten Daten mittels eines Akkumulationsregisters.
• Ausführungsbeispiel 19 ist ein Verfahren gemäß Ausführungsbeispiel 17 oder 18, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und der erste Operand und der zweite Operand rotiert, addiert oder beides werden.
• Ausführungsbeispiel 20 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 19, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und die der erste Operand und der zweite Operand multipliziert werden.
• Ausführungsbeispiel 21 ist ein Verfahren gemäß Ausführungsbeispiel 20, aufweisend Durchführen einer maskierten UND-Verknüpfung des ersten Operanden und zweiten Operanden die zur Realisierung der Multiplikation.
• Ausführungsbeispiel 22 ist ein Verfahren gemäß Ausführungsbeispiel 21, aufweisend Auffrischen der Maskierung der zu verarbeitenden Daten bei der maskierten UND-Verknüpfung.
• Ausführungsbeispiel 23 ist ein Verfahren gemäß einem der Ausführungsbeispiele 20 bis 22, wobei die Multiplikation eine Multiplikation über einem endlichen Körper GF(2ⁿ) ist.
• Ausführungsbeispiel 24 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 23, wobei jeder Block von Codewörtern aus den Codewörtern eines der zyklischen Codes besteht.
• Ausführungsbeispiel 25 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 24, aufweisend Korrigieren von durch Inhomogenität zwischen den Blöcken von Codewörtern entstehenden Fehlern.
• Ausführungsbeispiel 26 ist ein Verfahren gemäß Ausführungsbeispiel 25, aufweisend Korrigieren von durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehenden Fehlern.
• Ausführungsbeispiel 27 ist ein Verfahren gemäß Ausführungsbeispiel 25 oder 26, aufweisend Korrigieren von durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehende mangelnde Homomorphie der Maskierung bezüglich der Verschiebung von Daten.
• Ausführungsbeispiel 28 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 27, wobei alle Codes dieselbe Codewortlänge haben und die Codewortlänge gleich der Länge des Maskenerzeugungsvektors ist.
• Ausführungsbeispiel 29 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 28, wobei die Daten zur Durchführung einer kryptographischen Operation verarbeitet werden.
• Ausführungsbeispiel 30 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 29, wobei die Daten eine Signatur, einen kryptographischen Schlüssel, zu verschlüsselnde Daten und/oder zu entschlüsselnde Daten repräsentieren.
• Ausführungsbeispiel 31 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 30, wobei der Maskenerzeugungsvektor ein zufällig erzeugter Vektor ist.
• Ausführungsbeispiel 32 ist ein Verfahren gemäß einem der Ausführungsbeispiele 17 bis 31, wobei die mehreren zyklischen Codes unterschiedlich sind.
• Gemäß einem weiteren Ausführungsbeispiel wird ein Rechenwerk bereitgestellt aufweisend: Mittel zum Erzeugen einer Maske durch Multiplikation eines (beispielsweise zufällig erzeugten) Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes, Mittel zum Maskieren zu verarbeitender Daten mittels der Maske, und Mittel zum Verarbeiten der maskierten Daten mittels Additionen und Rotationen.
• Obwohl die Erfindung vor allem unter Bezugnahme auf bestimmte Ausführungsformen gezeigt und beschrieben wurde, sollte es von denjenigen, die mit dem Fachgebiet vertraut sind, verstanden werden, dass zahlreiche Änderungen bezüglich Ausgestaltung und Details daran vorgenommen werden können, ohne vom Wesen und Bereich der Erfindung, wie er durch die nachfolgenden Ansprüche definiert wird, abzuweichen. Der Bereich der Erfindung wird daher durch die angefügten Ansprüche bestimmt, und es ist beabsichtigt, dass sämtliche Änderungen, welche unter den Wortsinn oder den Äquivalenzbereich der Ansprüche fallen, umfasst werden.
• Bezugszeichenliste

100

Verarbeitungsvorrichtung

101

CPU

102

RAM

103

nicht-flüchtiger Speicher

104

Kryptomodul

105

Bus

106

Analogmodul

107

Eingabe-/Ausgabeschnittstelle

108-111

Krypto-Kerne

112

Hardware-Zufallszahlengenerator

200

ALU

201

Akkumulator

202

Registerbank

203, 204

Operandenregister

205

Steuerlogik

206

weitere Register

300

maskierte ALU

301

Akkumulator

303,304

Operandenregister

305-307

Maskenregister

308

Maskiertes UND

309

Maskiertes UND

310

XOR

311

XOR

312

Korrekturschaltung

313-316

XORs

400

Gatter

401,402

UND

403,404

XOR

500

Rechenwerk

501

Maskenerzeugungsschaltung

502

Maskierungsschaltung

503

ALU

600

Flussdiagramm

601-603

Verarbeitungsschritte

Claims (17)

1. Rechenwerk aufweisend: eine Maskenerzeugungsschaltung, die eingerichtet ist, eine Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes zu erzeugen, eine Maskierungsschaltung, die eingerichtet ist, zu verarbeitende Daten mittels der Maske zu maskieren, und eine arithmetisch-logische Einheit, die eingerichtet ist, die maskierten Daten mittels Additionen und Rotationen zu verarbeiten.
2. Rechenwerk gemäß Anspruch 1, wobei die arithmetisch-logische Einheit ein Akkumulationsschieberegister zum Verarbeiten der maskierten Daten aufweist.
3. Rechenwerk gemäß Anspruch 1 oder 2, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und die arithmetisch-logische Einheit eingerichtet ist, den ersten Operanden und den zweiten Operanden zu rotieren, zu addieren oder beides.
4. Rechenwerk gemäß einem der Ansprüche 1 bis 3, wobei die Daten einen ersten Operanden und einen zweiten Operanden aufweisen und die arithmetisch-logische Einheit eingerichtet ist, den ersten Operanden und den zweiten Operanden zu multiplizieren.
5. Rechenwerk gemäß Anspruch 4, aufweisend eine maskierte Auswahlschaltung, die zur Realisierung der Multiplikation eine maskierte UND-Verknüpfung des ersten Operanden und zweiten Operanden durchführt.
6. Rechenwerk gemäß Anspruch 5, wobei die maskierte Auswahlschaltung eingerichtet ist, die Maskierung der zu verarbeitenden Daten bei der maskierten UND-Verknüpfung aufzufrischen.
7. Rechenwerk gemäß einem der Ansprüche 4 bis 6, wobei die Multiplikation eine Multiplikation über einem endlichen Körper GF(2ⁿ) ist.
8. Rechenwerk gemäß einem der Ansprüche 1 bis 7, wobei jeder Block von Codewörtern aus den Codewörtern eines der nicht-systematischen zyklischen Codes besteht.
9. Rechenwerk gemäß einem der Ansprüche 1 bis 8, aufweisend eine Korrekturschaltung die eingerichtet, durch Inhomogenität zwischen den Blöcken von Codewörtern entstehende Fehler zu korrigieren.
10. Rechenwerk gemäß Anspruch 9, wobei die Korrekturschaltung eingerichtet ist, die durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehenden Fehler zu korrigieren.
11. Rechenwerk gemäß Anspruch 9 oder 10, wobei die Korrekturschaltung eingerichtet ist, die durch die Übergangsstellen zwischen den Blöcken von Codewörtern entstehende mangelnde Homomorphie der Maskierung bezüglich der Verschiebung von Daten zu korrigieren.
12. Rechenwerk gemäß einem der Ansprüche 1 bis 11, wobei alle Codes dieselbe Codewortlänge haben und die Codewortlänge gleich der Länge des Maskenerzeugungsvektors ist.
13. Rechenwerk gemäß einem der Ansprüche 1 bis 12, wobei das Rechenwerk eingerichtet ist, die Daten zur Durchführung einer kryptographischen Operation zu verarbeiten.
14. Rechenwerk gemäß einem der Ansprüche 1 bis 13, wobei die Daten eine Signatur, einen kryptographischen Schlüssel, zu verschlüsselnde Daten und/oder zu entschlüsselnde Daten repräsentieren.
15. Rechenwerk gemäß einem der Ansprüche 1 bis 14, wobei der Maskenerzeugungsvektor ein zufällig erzeugter Vektor ist.
16. Rechenwerk gemäß einem der Ansprüche 1 bis 15, wobei die mehreren zyklischen Codes unterschiedlich sind.
17. Verfahren zum Rechnen mit maskierten Daten aufweisend: Erzeugen einer Maske durch Multiplikation eines Maskenerzeugungsvektors mit Blöcken von Codewörtern mehrerer zyklischer Codes, Maskieren zu verarbeitender Daten mittels der Maske, und Verarbeiten der maskierten Daten mittels Additionen und Rotationen.

Images