DE60113678T2

DE60113678T2 - Generator für pseudo-zufallszahlen

Info

Publication number: DE60113678T2
Application number: DE60113678T
Authority: DE
Inventors: Egmont Felix GEIRINGER
Original assignee: TAO Group Ltd
Current assignee: TAO Group Ltd
Priority date: 2000-06-01
Filing date: 2001-05-24
Publication date: 2006-07-06
Anticipated expiration: 2021-05-25
Also published as: ATE305631T1; HK1056234A1; WO2001093013A1; EP1290544B1; KR20030027896A; DE60113678D1; EP1290544A1; US20040078576A1; ES2247109T3; GB0013349D0; AU2001258629A1; CA2410418A1; JP2003535377A

Description

Die vorliegende Erfindung betrifft einen Generator für Pseudo-Zufallszahlen und insbesondere, obgleich nicht ausschließlich, einen Generator zur Verwendung in Verschlüsselungssystemen, zum Beispiel einem Public-Key-Verschlüsselungssystem.
Die vorliegende Erfindung kann, in ihren verschiedenen Aspekten, bevorzugt in Verbindung mit einer Variation der in der NTRU PCT Patentanmeldung WO 98/08323 (die „NTRU-Patentanmeldung") offenbarten Verschlüsselungs- und Entschlüsselungsalgorithmen verwendet werden. Jedoch versteht sich, dass keiner der im Folgenden ausführlich dargelegten oder in den Ansprüchen definierten Aspekte der Erfindung auf die Verwendung in diesem spezifischen Kontext beschränkt ist.
US-A-6061703 offenbart einen Generator für Pseudo-Zufallszahlen mit einem geheimen Status, welcher mit einer von zwei Hash-Funktionen (eine zum Reseeding) aktualisiert wird, und einem Ausgabe- Tray, welcher befüllt wird, indem der geheime Status und ein Timer-Signal gehatched werden. US-A-5781458 offenbart das Extrahieren von Entropie aus dem Ausgabesignal eines RC-Schwingkreises. US-A-5778069 offenbart einen Computerimplementierten Generator für Pseudo-Zufallszahlen, welcher eine Hash-Recheneinrichtung aufweist.
Die Erfindung kann auf verschiedene Art und Weise in der Praxis angewandt werden, und eine spezifische und bevorzugte Ausführungsform wird nun als Beispiel mit Bezug auf die beigefügten Zeichnungen beschrieben, wobei:
1 das Schlüsselerzeugungssystem in Tumbler illustriert;
2 das Verschlüsselungssystem illustriert;
3 das Entschlüsselungssystem illustriert;
4 die Fehlerkorrekturalgorithmen illustriert;
5, 6 und 7 das Konzept eines Wrapping-Fehlers illustriert;
8 die Reihenfolge illustriert, in welcher Koeffizienten auf mögliche Fehler geprüft werden;
9 einen typischen Generator für Pseudo-Zufallszahlen des Standes der Technik (PRNG) illustriert;
10 den PRNG in Tumbler illustriert;
11 einen Schaltplan zur Addition modulo 3 illustriert;
12 einen Schaltplan zur Subtraktion modulo 3 illustriert; und
13 einen Schaltplan zur Multiplikation modulo 3 illustriert.
1. Einführung
Tumbler^TM ist der Markenname des Verschlüsselungsentwickler-Toolkits des vorliegenden Anmelders. Es enthält eine Reihe unterschiedlicher Verschlüsselungsalgorithmen und nicht-algorithmusspezifischer APIs, ist jedoch primär, jedoch nicht ausschließlich, um den NTRU PKCS-Algorithmus herum aufgebaut, wie er von der NTRU Corporation entwickelt wurde. Details dazu finden sich in Hoffstein, Pipher and Silverman, NTRU: A Ring-Based Public Key Cryptosystem, J P Buhler (ed.), Lecture Notes in Computer Science 1423, Spring-Verlag, Berlin, 1998, 267–288; und in der PCT-Patentanmeldung WO 98/08323 im Namen der NTRU Cryptosystems, Inc. Auf letztgenanntes Dokument wird sich im Folgenden durchgängig als die "NTRU-Patentanmeldung" bezogen.
Dieser Algorithmus stellt einen Durchbruch in der Kryptographie dar. Ausgehend von der traditionellen Welt von ,Big Integer'-basierten Produkten bietet er effizientere und sicherere Systeme basierend auf einer Polynommischungsmethode. Ein beliebiger bloßer Algorithmus ist jedoch bei weitem nicht als ein Verschlüsselungsprodukt verwendbar. Dazwischen ist eine ganze Menge an Technik erforderlich. Im Falle von NTRU bedeutet sein einzigartiger Stil, welcher die Grundlage seiner Überlegenheit darstellt, dass viel von dieser Technik neu erfunden werden muss, um die Algorithmen zu bewältigen.
Dieses Dokument beschreibt die einmalige Implementierung des NTRU PKCS (Public-Key-Verschlüsselungssystem), welches in Tumbler enthalten ist. Es umreißt die Probleme, denen man gegenübersteht, wenn man versucht, das NTRU PKCS als ein reelles Verschlüsselungstool zu implementieren und erklärt, wie Tumbler innovative Verfahren einsetzt, um diese Probleme zu lösen.
Es versteht sich, dass viele der in Tumbler verwendeten innovativen Verfahren unabhängig voneinander sind und einzeln oder in einer beliebigen ausgewählten Kombination verwendet werden könnten. Zum Beispiel könnten die folgenden Verfahren, obwohl sie alle in der bevorzugten Tumbler-Ausführungsform enthalten sind, einzeln oder in einer beliebigen Kombination verwendet werden: Fehlerkorrektur, Nachrichtenendmarkierung, Prüfmechanismus, Generator für Pseudo-Zufallszahlen mit großem Status, Verwendung von Modulo-Arithmetik und Schutz gegen multiple Übertragungsangriffe. Es versteht sich außerdem, dass, obwohl Tumbler primär um den NTRU PKCS-Algorithmus aufgebaut ist, wie in der NTRU-Patentanmeldung ausführlich dargelegt, die meisten der innovativen Verfahren eine viel breitere Anwendung finden.
1.1 Die ursprüngliche NTRU PKCS-Patentanmeldung
Die NTRU-Patentanmeldung beschreibt ein Verfahren zum Erzeugen von zwei zusammengehörenden Polynomen, genannt der öffentliche Schlüssel und der private Schlüssel. Sie enthält außerdem eine Demonstration, wie der öffentliche Schlüssel verwendet werden kann, um eine Nachricht umzuwandeln, und zwar in Form eines Polynoms in eine verschlüsselte Form. Diese verschlüsselte Nachricht ist sicher, da das Abrufen der ursprünglichen Nachricht, wenn nur die verschlüsselte Nachricht und der öffentliche Schlüssel bekannt sind, eine viel zu komplexe Aufgabe ist, als das sie in einem angemessenen Zeitraum durch eine aktuelle Technologie ausgeführt werden könnte. Die verschlüsselte Form könnte auch die Mittel zum sicheren Übertragen (oder Speichern) der Nachricht darstellen, da die Kenntnis des privaten Schlüssels üblicherweise das Wiederherstellen der ursprünglichen Nachricht zulässt.
1.2 Eine unvollständige Lösung
Unter Verwendung des privaten Schlüssels und der verschlüsselten Form kann die ursprüngliche Nachricht üblicherweise wiederhergestellt werden. Wenn die Nachricht nicht wiederhergestellt werden kann, so geschieht dies aufgrund von Fehlern, welche Wrapping- oder Gap-Fehler genannt werden. Man glaubte ursprünglich, dass Wrapping-Fehler mit einem vorhandenen Verfahren leicht zu beheben wären, und dass Gap-Fehler so selten auftreten, dass sie unberücksichtigt gelassen werden können (NTRU-Patentanmeldung § 1.3, S. 31). Es zeigte sich jedoch, dass das zum Reparieren von Wrapping-Fehlern vorgeschlagene Verfahren den Fehler oft nicht korrigierte, und dass Gap-Fehler häufig genug vorkamen, um die Nutzbarkeit erheblich zu beeinträchtigen. Außerdem gab es das Problem der Fehlererkennung. Da die Person, welche versucht die Nachricht zu entschlüsseln, üblicherweise nicht im Besitz des Originals ist, ist es für sie schwierig festzustellen, ob die Nachricht korrekt entschlüsselt wurde oder nicht.
In der Computersprache ist eine beliebige Datei eine beliebig lange Zeichenfolge aus Binärziffern. Das Chiffrierverfahren, wie in der ursprünglichen NTRU-Patentanmeldung beschrieben, verschlüsselt Ternärpolynome einer festen Länge. Es ist daher notwendig, ein Verfahren bereitzustellen, welches eine Datei so in eine Sequenz von Ternärpolynomen mit fester Länge umwandelt, dass die so entstehende Sequenz von Polynomen in die ursprüngliche Datei zurückgewandelt werden kann.
Während der normalen Verwendung eines Chiffrierverfahrens gibt es gewisse Personen, bekannt als Angreifer, welche fortwährend versuchen, es zu „knacken". Dort wo das NTRU PKCS eingesetzt wird, ist das Abrufen der ursprünglichen Nachricht, wenn nur die verschlüsselte Nachricht und der öffentliche Schlüssel bekannt sind, eine viel zu komplexe Aufgabe, als dass sie in einer angemessenen Zeitspanne durch aktuelle Technologie ausgeführt werden könnte. Die Lösung für einen Angreifer ist das in Erfahrung bringen von mehr Informationen als nur der verschlüsselten Nachricht und des öffentlichen Schlüssels.
Je nachdem wie das Chiffrierverfahren verwendet wird, kann es für den Angreifer tatsächlich möglich sein, weitere Informationen in Erfahrung zu bringen, welche zum „Knacken" der Chiffre von Nutzen sind. Die einfache Antwort wäre, das Chiffrierverfahren nicht auf eine Art und Weise zu verwenden, welche dies zulässt. Unter gewissen Umständen kann dies jedoch für praktische Zwecke zu einschränkend sein. Die beiden im Folgenden angesprochenen Situationen sind solche, in denen es gewünscht wird, die exakt gleiche Nachricht mehrfach zu versenden, oder ein automatisches System einzurichten, zu dem ein potentieller Angreifer Zugriff haben könnte.
Die NTRU-Patentanmeldung beschreibt den theoretischen Algorithmus für das Chiffrierverfahren, spricht jedoch nicht an, wie ein reelles Gerät die Ausführung dieses Algorithmus in Angriff nehmen würde. Der theoretische Algorithmus umfasst relativ wenige Schritte und verwendet Mathematik, welche von modernen Computern schnell ausgeführt werden kann, und ist so an sich schnell. Die vorliegenden Anmelder stellen jedoch Verfahren bereit, welche die Geschwindigkeit dieses Algorithmus drastisch erhöhen.
1.3 Die Tumbler-Lösung
Tumblers Implementierung des NTRU PKCS schließt die Lücke zwischen Theorie und Praxis. Es umfasst außerdem eine Reihe neuer Verfahren, welche auf den bei NTRU gemachten Fortschritten aufbauen, und kann selbst in anderen Bereichen der Kryptographie, Datensignalverarbeitung und Berechnung verwendet werden.
Es folgen detaillierte Verfahren zum Erkennen von Fehlern und dem Korrigieren von sowohl Wrapping- als auch Gap-Fehlern. Damit das Chiffrierverfahren als ein praktisches Mittel zum Sichern von Daten eingesetzt werden kann, muss man in der Lage sein, sich auf die Integrität der entschlüsselten Nachricht verlassen zu können.
Durch die Verwendung der in der NTRU-Patentanmeldung beschriebenen ursprünglichen Verfahren zusammen mit dem im Folgenden dargelegten Erkennungs- und Korrektursystem ist dies schließlich, so glaubt man, der Fall.
Ein kohärentes „Bit-zu-Tert"-Umwandlungsschema arbeitet in Verbindung mit einem ursprünglichen „Nachrichtenendmarkierungs"-System zur Schnittstellenbildung zwischen Standardcomputerdateien und NTRU PKCS-Polynomen.
Tumbler beinhaltet Prozesse, welche neben dem NTRU PKCS arbeiten und welche es dem Nutzer ermöglichen, die exakt gleiche Nachricht mehrfach zu versenden, oder ein automatisiertes System zu verwenden, auf welches durch einen potentiellen Angreifer zugegriffen werden könnte, ohne die Sicherheit des Chiffrierverfahrens zu zerstören. Zusätzlich zum Analysieren einer ganzen Palette von Standardmathematiktools, um die optimale Lösung zum Verarbeiten des NTRU PKCS zu finden, haben die Entwickler von Tumblers NTRU PKCS-Implementierung einige scheinbar anti-intuitive ursprüngliche Verfahren entwickelt, welche viele der NTRU PKCS-Daten mit einer enorm erhöhten Geschwindigkeit verarbeiten.
Um die gewerblich Kryptographie mit Hilfe des NTRU PKCS zu vereinfachen, ist es notwendig, diesen internen Algorithmus mit einer Vielzahl von Mechanismen zu kombinieren, welche zum Schutz der Verwendung des Chiffrierverfahrens gegenüber üblichen Angriffen ausgelegt sind, zur Schnittstellenbildung zwischen dem Chiffrierverfahren und dem regulären digitalen Datenhandling, sowie auch zur Überwindung von inhärenten Problemen des Chiffrierverfahrens. Der vorliegende Anmelder glaubt, dass all dies in Tumbler erreicht wurde.
2. Mathematische Terminologie
Das NTRU-Verschlüsselungssystem und die Tumbler-Version sind abhängig von drei ganzzahligen Parametern (N, p, q) und vier Polynomsätzen (Lf, Lg, LΦ, Lm) eines Grades nicht höher als N – 1 mit ganzzahligen Koeffizienten. Es wird darauf hingewiesen, dass p und q keine Primzahlen sein müssen, es sollte jedoch angenommen werden, dass der ggT(p, q) = 1, und dass q immer wesentlich größer ist als p. Bei der Tumbler-Implementierung ist p normalerweise 3, und q ist normalerweise 64, 128 oder 256, je nach der Größe von N. Andere Implementierungen können andere Werte verwenden.
Es wird innerhalb des Ringes beschnittener ganzzahliger Polynome R = Z[X]/(X^N – 1) gearbeitet. Ein Element F ∈ R wird als ein Polynom oder ein Vektor geschrieben,
Addition und Subtraktion funktionieren bei R auf genau die gleiche Art und Weise wie in der normalen Polynomarithmetik. Multiplikation erfordert jedoch Reduktion modulo (X^N – 1).
Das Symbol * kennzeichnet Multiplikation bei R. Diese Sternmultiplikation ist explizit als ein zyklisches Faltungsprodukt gegeben,
Es wird darauf hingewiesen, dass dies genau das Gleiche wie gewöhnliche Polynommultiplikation ist, außer dass die Koeffizienten „zyklisch" sind, so dass der Koeffizient von X^N mit dem konstanten Koeffizienten kombiniert wird (dazu hinzugefügt), der Koeffizient von X^N+1 wird mit dem Koeffizienten von X kombiniert, usw.
In der Praxis ist man üblicherweise am Wert der Koeffizienten modulo p oder q eines Polynoms interessiert. Tatsächlich treten viele der Operationen in den Ringen Zp[X]/(X^N – 1) oder Zq[X]/(X^N – 1) auf, es ist jedoch wünschenswert, den Rest eines einzelnen Polynoms sowohl modulo p als auch q reduziert zu betrachten.
Wenn man eine Multiplikation modulo (sagen wir) q ausführt, dann mit der Absicht, Koeffizienten modulo q zu verringern.
Bei der Reduktion modulo einer ganzen Zahl p, gilt es, sich zweier nützlicher Regeln zu erinnern: a(mod p) + b(mod p) = (a + b)(mod p), (c(mod p) × a(mod p))(mod p) = (c × a)(mod p).
R ist kein Feld. Jedoch wurden die NTRU-Parameter so ausgewählt, dass es extrem wahrscheinlich ist, dass angemessen ausgewählte Polynome Inverse in R haben. R ist eine einmalige Faktorisierungsdomäne, so dass diese Inversen, wenn sie existieren, einmalig sind.
L_m besteht aus allen Polynomen in R mit Koeffizienten modulo p. Die Elemente von L_f, L_g und L_Φ besitzen auch Koeffizienten modulo p, besitzen jedoch ein vorbestimmtes Gewicht. Polynome in L_g und L_Φ sind so definiert, dass sie jeweils genau d_g(N) und d_Φ(N) Koeffizienten mit dem Wert 1 besitzen, d_g(N) und d_Φ(N) Koeffizienten mit dem Wert –1, und die übrigen Koeffizienten haben alle den Wert 0. Polynome in Lf sind so definiert, dass sie d_f(N) Koeffizienten mit dem Wert 1 besitzen und d_f(N) – 1 Koeffizienten mit dem Wert –1, während alle übrigen Koeffizienten den Wert 0 besitzen. Die Polynome in Lf besitzen einen Koeffizienten mit dem Wert 1 weniger, damit sie invertierbar sind.
3. Überblick
Das Tumbler-Kryptographiesystem setzt sich aus drei separaten Systemen zusammen: einem Schlüsselerzeugungssystem, einem Verschlüsselungssystem und einem Entschlüsselungssystem. Dieser Abschnitt untersucht kurz jedes dieser drei Systeme und legt dar, wie jedes aus einer Reihe zugrundeliegender Prozesse konstruiert ist.
Die NTRU-Patentanmeldung beschreibt die Verschlüsselung und Entschlüsselung als sehr einfache zwei- oder dreistufige Prozesse. Die Tumbler-Implementierung hat viele zusätzliche Merkmale eingeführt, welche diese Prozesse erheblich komplizierter machen. Jeder der drei folgenden Prozesse wird mit Hilfe eines Flussdiagramms beschrieben. Es ist interessant, diese drei Flussdiagramme mit ihren Äquivalenten aus der NTRU-Patentanmeldung (3, 4 & 5) zu vergleichen.
Im Falle des Schlüsselerzeugungssystems ist der Prozess relativ einfach geblieben. Jedoch wurden genau bei der Schlüsselerzeugung die größten Fortschritte in der Effizienz erzielt.
3.1 Schlüsselerzeugung
Hier wird das Schlüsselerzeugungssystem beschrieben, wie es in 1 (vgl. 3 der NTRU-Patentanmeldung) erscheint.

101. Das Schlüsselerzeugungssystem übernimmt die Algorithmusparameter N und q. Der in der NTRU-Patentanmeldung verwendete Parameter p ist auf 3 festgelegt. Es können jedoch auch andere Werte verwendet werden.
102. Das Polynom des privaten Schlüssels, f wird zufällig aus dem Satz Lf ausgewählt, welcher, wie in der NTRU-Patentanmeldung beschrieben (§1.2, S. 31), von N abhängig ist.
103. Die Inverse von f wird modulo 3 berechnet. Anstelle des „Euklid-Algorithmus" wird der effizientere „Almost-Inverse-Algorithmus" verwendet. Diesen Algorithmus findet sich in dem Aufsatz ,Fast Key Exchange with Elliptic Curve Systems' von Richard Schaeppel, et al (Advances in Cryptology – CRYPTO 95, Lecture Notes in Computer Science 973, ed. D. Coppersmith, Springer-Verlag, New York, 1995, S. 43–56). Es ist möglich, dass die Inverse nicht existiert. In diesem Fall kehrt man zu 102 zurück und wählt ein neues f. Bei der Implementierung dieses Algorithmus wird ein Prozess schneller Moduloarithmetik durch parallele Bitoperationen auf einer Vektordarstellung verwendet (weitere Einzelheiten dazu siehe § 12).
104. Wie bei 103, außer dass die Invers von f modulo 2 berechnet wird. Sei der Implementierung dieses Algorithmus wird ein Prozess schneller Moduloarithmetik durch parallele Bitoperationen auf einer Vektordarstellung verwendet (siehe §12).
105. Mit einer gegebenen Inversen modulo einer Primzahl ist es möglich, daraus die Inverse modulo einer Potenz dieser Primzahl zu berechnen, wobei das gut bekannte mathematische Verfahren, welches umgangssprachlich „Bootstrapping" genannt wird, zum Einsatz kommt. Dies ermöglicht es uns, die Inverse modulo q (welche immer eine Potenz von 2 ist) aus der Inversen modulo 2 zu berechnen. „Bootstrapping" verwendet das folgende Prinzip. Wenn F die Inverse von f modulo einer Potenz einer Primzahl p^m ist, dann ist 2F – f * F² die Inverse von f modulo p^2m.
106. g wird zufällig ausgewählt, ähnlich wie f, jedoch aus dem Satz Lg.
107. Dies ist die gleiche Berechnung wie die, die in der NTRU-Patentanmeldung (3, Schritt 350) ausgeführt wird, außer dass zur leichteren Handhabbarkeit der Faktor p (= 3) eingefügt wurde.
108. Der private Schlüssel ist das Paar f, F₃.
109. Der öffentliche Schlüssel h kann dann veröffentlicht werden. Dieser wurde in Schritt 107 berechnet.

3.2 Verschlüsselung
Hier wird das Tumbler-Verschlüsselungssystem beschrieben, wie es in 2 erscheint. Dies sollte mit dem ursprünglichen in der NTRU-Patentanmeldung beschriebenen Verschlüsselungssystem (4) verglichen und ihm gegenübergestellt werden.
In 2 wird das Symbol II verwendet, um die Verkettung der Objekte auf der jeweiligen Seite zu bezeichnen.

201. Das Verschlüsselungssystem übernimmt die ursprünglichen Nachrichtendaten (den Klartext), P, als eine (binäre) Folge von Bytes mit einer unbestimmten Länge, das Polynom des öffentlichen Schlüssels, h, die Algorithmusparameter N und q, und, falls notwendig, eine Schutzschlüssellänge gegen multiple Übertragungsangriffe (MTA-Schlüssel), k. Der Prozess verwendet außerdem die SHA-1-Hash-Funktion, H(). SHA-1 ist in den Secure Hash Standards des National Institute of Standards and Technology der US-Regierung (FIPS 180-1) definiert. Es versteht sich natürlich, dass der Klartext P die tatsächliche alphanumerische (oder andere) Nachricht darstellt, welche gemäß einer beliebigen herkömmlichen Standardbinärdarstellung verschlüsselt werden soll.
202. Falls das Chiffrierverfahren Schutz gegen multiple Übertragungsangriffe erfordert, wird dieser vor der Verschlüsselung auf den Klartext angewandt (siehe § 7). Bei einem k ungleich null werden k Bytes zufälliger Daten (K) erzeugt, und diese Bytes werden als Seed für den Sequenzgenerator verwendet (siehe § 11). Wird kein MTA-Schutz verwendet, dann ist k = 0, K = Ø, allerdings wird die Sequenz S(K) logisch als alles Nullen betrachtet. In der Praxis hat eine Sequenz, welche nur aus Nullen besteht, keine Auswirkung. Dies ist nicht das Gleiche wie S(Ø)!
203. Der MTA-Schlüssel, K, bildet die ersten k Bytes des Klartextes zur Eingabe in das Chiffrierverfahren (siehe § 7). Dem folgen dann die ursprünglichen Bytes der Klartextdaten, XORed mit der Ausgabe des Sequenzgenerators (siehe § 11). Zum Verschlüsseln des XORed Klartextes ist es notwendig, die Binärdaten in Ternärdaten umzuwandeln, um die Ternärpolynome (m) zu füllen, welche vom Chiffrierverfahren verwendet werden (siehe § 8). Diese Ternärziffern oder „Terts" bilden die Nachrichtenpolynome, welche dann durch das PKCS-Chiffrierverfahren verarbeitet werden. Wenn weniger als N Terts unverarbeitet bleiben, dann werden die verbleibenden Terts in das nächste Nachrichtenpolynom übernommen, und in 207 wird eine Nachrichtenendmarkierung erzeugt.
204. Vorausgesetzt genügend Terts bleiben unverarbeitet, wird ein Nachrichtenpolynom aus den nächsten N konstruiert und dann verschlüsselt. Sind die Klartextdaten aufgebraucht und es sind nicht mehr genügend Terts vorhanden, um das nächste Nachrichtenpolynom zu füllen, wird in 207 eine Nachrichtenendmarkierung erzeugt.
205. Ein zufälliges Polynom wird ausgewählt und mit dem öffentlichen Schlüssel multipliziert. Das Produktpolynom wird dann zum Nachrichtenpolynom hinzugefügt. Dieser Prozess ist identisch zu dem in der NTRU-Patentanmeldung (4, Schritt 450) beschriebenen, außer dass der Parameter p in den öffentlichen Schlüssel eingefügt worden ist. Das so entstehende Chiffrierpolynom wird dann gepackt, um Bytes zu füllen und wird in eine Prüf-Hash-Funktion eingegeben, gefolgt von dem Nachrichtenpolynom unter Verwendung von 2 Bit pro Koeffizient, welches auch gepackt wird, um Bytes zu füllen. Der Prüf-Hash wird berechnet und mit dem Ende des Chiffrierpolynoms verkettet (siehe § 6). Die Ausgabe von diesem Hash bildet den Prüfblock B_i.
206. Nach der Verschlüsselung eines Nachrichtenpolynoms wird dann mit dem nächsten Polynom fortgefahren, wobei die nächsten N Terts Klartext verwendet werden.
207. Es ist unwahrscheinlich, dass die Klartextdaten eine genaue Anzahl von Nachrichtenpolynomen oder sogar ein genaues Vielfaches von 19 Bit zur Umwandlung in Terts füllen. Wenn alle Polynome, welche unter Verwendung des in 203, 204, 205 & 206 beschriebenen Prozesses komplett gefüllt werden können, verarbeitet wurden, wird das letzte Nachrichtenpolynom mit Hilfe des Nachrichtenendmechanismus (siehe § 9) vervollständigt. Dieser Mechanismus erzeugt eine 12-Tert-Nachrichtenendmarkierung. Diese Markierung wird in den Klartext eingefügt und passt möglicherweise nicht in das letzte unvollständige Nachrichtenpolynom. In diesem Fall reicht die Nachrichtenendmarkierung bis hinüber in ein weiteres Nachrichtenpolynom. Das letzte Polynom wird falls notwendig mit zufälligen Terts vervollständigt.
208. Das letzte Nachrichtenpolynom (oder möglicherweise die letzen beiden Nachrichtenpolynome), welche das letzte unvollständige Klartextnachrichtpolynom und die Nachrichtenendmarkierung enthalten, werden nun auf die gleiche Art und Weise verschlüsselt wie alle anderen Nachrichtenpolynome.
209. Die Verkettung jedes verschlüsselten Polynoms, gepackt zum Füllen von Bytes, jedoch mit dem letzten unvollständigen Byte (falls es existiert) aufgefüllt mit Nullen, unmittelbar gefolgt von seinem dazugehörigen Prüfblock, bildet die verschlüsselte Nachricht (Schlüsseltext).

3.3 Entschlüsselung
Hier wird das Tumbler-Entschlüsselungssystem beschrieben, wie es in 3 erscheint. Es sollte mit dem ursprünglichen in der NTRU-Patentanmeldung beschriebenen Entschlüsselungssystem (5) verglichen und ihm gegenübergestellt werden.

301. Das Entschlüsselungssystem übernimmt die Algorithmusparameter N und q, den Chiffriertext, E, die Polynome des privaten Schlüssels, f und F₃, das Fehlerkorrekturlevel und, falls notwendig, den MTA-Schlüssel, k. Der Prozess nutzt außerdem die SHA-1-Hash-Funktion, H(). In 3 wird das Symbol ∥ verwendet, um die Verkettung der Objekte auf der jeweiligen Seite zu bezeichnen.
302. i ist ein Zähler, welcher verwendet wird, um, in Reihenfolge, auf spezifische verschlüsselte Polynome zu verweisen. R enthält die entschlüsselten Klartextdaten, auf die der MTA-Schutz noch angewandt ist (siehe § 7).
303. Jedes verschlüsselte Polynom und sein zugehöriger Prüfblock werden aus dem Schlüsseltext rekonstruiert, indem einfach die in 209 verwendete Packsequenz umgekehrt wird.
304. Die Nachricht wird mit dem privaten Schlüssel multipliziert und dann mit der Inversen des privaten Schlüssels. Dies ist identisch mit dem in der NTRU-Patentanmeldung beschriebenen Prozess (5, Schritt 570 und 580), außer dass das Ergebnis der ersten Multiplikation aufgezeichnet wird für den Fall, dass es zur Fehlerkorrektur benötigt wird.
305. Aus e_i und b_i wird ein Hash erzeugt, und zwar auf die gleiche Art und Weise wie der von e_i und m_i in 205 (siehe § 6), wobei das entschlüsselte Polynom b_i als das Nachrichtenpolynom m; behandelt wird. Dieser Hash wird mit dem übertragenen Prüfblock B_i verglichen. Für den Fall, dass für ein Polynom eine Fehlerkorrektur angewandt werden muss, müssen möglicherweise viele solcher Hashes mit Hilfe des gleichen e_i berechnet werden. Es kann daher effizient sein, den Status der Hash-Funktion nach der Eingabe von e_i, jedoch vor der Eingabe von b_i, aufzuzeichnen.
306. Wenn der übertragene Prüfblock mit dem in 305 erzeugten Hash übereinstimmt, dann wird das entschlüsselte Polynom, b_i, als das ursprüngliche i^–te Nachrichtenpolynom akzeptiert. Die Terts dieser Nachrichtenpolynome müssen in Bits zurückgewandelt werden (siehe § 8). Diese Umwandlung wird in Sätzen von 12 Terts durchgeführt.
307. Die Bit-zu-Tert-Umwandlung wandelt Sätze von 19 Bits in einen Untersatz der möglichen Sätze von 12 Terts um. Wenn ein Satz von 12 Terts ein Mitglied dieses Untersatzes ist, wird er zur Rückwandlung in Bits weitergereicht, ansonsten handelt es sich nicht um einen umgewandelten Satz von 19 Bits, sondern um eine Nachrichtenendmarkierung (siehe § 9).
308. Die Terts werden in Bits umgewandelt (siehe § 8) und das Ergebnis wird mit R verkettet. R ist natürlich eine binäre Zeichenfolge (welche eine Sequenz von Bytes darstellt).
309. Nach dem Entschlüsseln des vorhergehenden Polynoms fährt das Entschlüsselungssystem mit dem nächsten verschlüsselten Polynom fort.
310. Wenn der übertragene Prüfblock nicht mit dem in 305 erzeugten Hash übereinstimmt, dann ist das entschlüsselte Polynom, b_i, nicht das ursprüngliche i^–te Nachrichtenpolynom.
311. Ist die optionale Fehlerkorrektur aktiv, versucht das Fehlerkorrektursystem das ursprüngliche Nachrichtenpolynom wieder herzustellen (siehe § 5).
312. Das Fehlerkorrektursystem erstattet Bericht über seinen Erfolg. Wenn es erfolgreich ist, wird das entstehende b_i (ein anderes b_i als das in 304 berechnete) als das nächste Nachrichtenpolynom akzeptiert und das Dechiffrierverfahren fährt ganz normal fort.
313. Dieser Punkt wird erreicht, falls ein Fehler aufgetreten ist und nicht korrigiert wurde. Der ursprüngliche Klartext kann daher nicht wiederhergestellt werden. In den meisten Fällen wird an dieser Stelle die gesamte Nachricht verworfen. Dies geschieht, weil die meisten Anwendungen eines PKCS die gesamte intakte Nachricht erfordern. Es ist jedoch möglich, einfach aufzuzeichnen, welche Bytes des entstehenden Klartextes zu dem aktuellen inkorrekten Nachrichtenpolynom gehören, zu Stufe 306 zurückzukehren und ganz normal fortzufahren. Dann sind nur diejenigen Klartextbits, welche direkt aus dem falschen Nachrichtenpolynom umgewandelt wurden, betroffen.
314. Ein den festgelegten Bereich überschreitender Satz von 12 Terts steht für eine Nachrichtenendmarkierung. Alle vorherigen Tertblöcke werden in Bits umgewandelt und mit R verkettet. Schließlich wird dieser Block mit Hilfe des Nachrichtenendmechanismus übersetzt (siehe § 9). Dies kann das Entfernen einiger der in R enthaltenen Bits erfordern. Terts, welche bisher noch nicht umgewandelt wurden, werden verworfen.
315. An dieser Stelle ist R die Klartextdaten, auf die der MTA-Schutz noch angewandt ist. Die ersten k Bytes bilden den MTA-Schlüssel K. Diese dienen als Seed für einen Sequenzgenerator S(K). Wird kein MTA-Schutz verwendet, dann ist k = 0, K = Ø, jedoch geht man logisch davon aus, dass die Sequenz S(K) aus alles Nullen besteht. In der Praxis hat eine Sequenz, welche nur aus Nullen besteht, keine Wirkung. Dies ist nicht das Gleiche wie S(Ø)! Die Ausgabe von S(K) wird mit R XORed, um P zu erzeugen (siehe § 7).
316. Die wiederhergestellten Klartextdaten sind die binäre Zeichenfolge P, welche die Bytes der eigentlichen Nachricht darstellt.

4. Entschlüsselungsfehler
Immer wenn ein Schlüsselpolynom mit Hilfe des NTRU-Algorithmus entschlüsselt wird, besteht die geringe Wahrscheinlichkeit, dass er bei der Rückentschlüsselung des ursprünglichen Nachrichtenpolynoms versagt.
Zum Entschlüsseln des Schlüsselpolynoms e mit Hilfe des privaten Schlüssels f berechnet man zuerst a = f * e(mod q),durch Auswahl der Koeffizienten von a im Intervall von –q/2 + 1 bis q/2. Indem a als ein Polynom mit ganzzahligen Koeffizienten behandelt wird, kann das Nachrichtenpolynom üblicherweise wiederhergestellt werden, indem Folgendes berechnet wird Fp * a(mod p),wobei F_p die Inverse von f modulo p ist (F_p * f ≡ 1(mod p)).
Das Polynom a erfüllt a ≡ f * e = f * Φ * h + f * m(modq) = f * pΦ * Fq * g + f * m(modq) = pΦ * g + f * m(mod q)
Betrachten Sie dieses letzte Polynom pΦ * g + f * m. Zur Auswahl geeigneter Parameter besteht die Möglichkeit sicherzustellen, dass in nahezu jedem Fall alle seine Koeffizienten zwischen –q/2 + 1 und q/2 liegen, so dass es sich nicht verändert, wenn seine Koeffizienten modulo q reduziert werden. Das bedeutet, dass die Verringerung der Koeffizienten von f * e modulo q in den Intervall von –q/2 + 1 bis q/2 exakt das folgende Polynom wiederherstellt a = pΦ * g + f * m.
Die „Auswahl geeigneter Parameter" bezieht sich primär auf die Werte d_g(N), d_Φ(N) und d_f(N), definiert in § 2. Je niedriger diese Werte sind, desto größer ist der Anteil an Koeffizienten in den Polynomen g, Φ und f gleich Null. Dadurch wird die Wahrscheinlichkeit, dass ein Koeffizient in dem obengenannten Polynom nahe Null ist, größer. Jedoch bestimmen diese Werte auch, wie viele mögliche Polynome es von jedem Typ gibt, und somit wie effektiv die Sicherheit des Chiffrierverfahrens ist. Wenn diese Werte große genug sind, gibt es zu viele mögliche Werte von g, Φ und f, als dass ein Angreifer in der Lage sein würde, ihren exakten Wert in einer angemessenen Zeitspanne zu erraten. Wenn diese Werte so klein sind, dass keine Chance besteht, dass einer der Koeffizienten in dem obengenannten Polynom außerhalb des Bereiches –q/2 + 1 bis q/2 liegt, dann ist die Sicherheit des Schlüssels gefährdet.
Die in Tumbler verwendete Parameterauswahl ergibt eine Wahrscheinlichkeit von circa 1 in 10000, dass das Polynom pΦ * g + f * meinen Koeffizienten aufweist, welcher außerhalb des Bereiches –q/2 + 1 bis q/2 liegt. Das bedeutet, dass der Wert einiger Koeffizienten während des ersten Schrittes der Entschlüsselung durch ±q umgesetzt wird und daher einen veränderten Wert modulo 3 aufweist.
Beispiel
5, 6 und 7 geben ein visuelles Beispiel eines Wrapping-Fehlers.
5 stellt ein Beispielpolynom f * e dar, welches auf die am wenigsten positiven Reste modulo q reduziert wurde. Fünfzig Koeffizienten werden durch Punkte dargestellt, welche sich an Höhen relativ zu ihrem Wert (zwischen 0 und q) befinden. Dies ist das Polynom, welches das Entschlüsselungsgerät bei der Hälfte des Entschlüsselungsprozesses wiederherstellt. Das Polynom wird mit Hilfe der am wenigsten positiven Restklassen angezeigt, da die einfachste Reduktion modulo eine Potenz von 2 in einem Computer Zahlen in diesen Klassen ergeben wird. Um die Nachricht wiederherzustellen, muss das Polynom in die am wenigsten absoluten Restklassen (zwischen –q/2 + 1 und q/2) verschoben werden.
Jedoch hat die derzeitige Form des Polynoms den Vorteil, dass alle Koeffizienten, die am wahrscheinlichsten inkorrekt wrappen, in der Mitte des Polynoms versammelt sind. Diese Zone ist in dem Diagramm hervorgehoben (der als 501 markierte Bereich).
6 zeigt das gleiche Polynom wie in 5, außer dass es nun in die am wenigsten absoluten Restklassen modulo q verschoben wurde. Der in 5 als 501 markierte Bereich ist nun zweigeteilt und als 601 und 602 markiert. Der Koeffizient, welcher in 5 als 502 markiert wurde, lag gerade über der q/2-Linie und wurde daher um q nach unten verschoben und befindet sich nun am unteren Rand des Diagramms (markiert als 603). Dies ist die Form des Polynoms, welche mit F₃ gefaltet wird, um das ursprüngliche Nachrichtenpolynom wiederherzustellen.
7 zeigt das Polynom pΦ * g + f * m, welches sich auf das in 5 und 6 gezeigte Polynom bezieht. Dieses Polynom ist nicht modulo q reduziert, man hofft jedoch, dass seine Koeffizienten alle innerhalb des Bereiches –q/2 + 1 bis q/2 liegen, so dass das Polynom aus 6 eine exakte Übereinstimmung ist. Wenn dem so ist, wird die Nachricht ohne Fehler wiederhergestellt. Dies geschieht, mit angemessener Parameterauswahl, bis auf wenige Ausnahmen in allen Fällen. In diesem Beispiel liegt der als 701 markierte Koeffizient außerhalb des angegebenen Bereiches. Das bedeutet, dass das Polynom f * e, welches in 6 gezeigt wurde, während es zu diesem Polynom modulo q äquivalent ist, nicht das Gleiche und nicht äquivalent modulo 3 ist. Der Koeffizient 701 wurde in die als 603 markierte Position in 6 gewrapped.
Es ist wichtig, dass ein Mittel existiert, durch welches es möglich ist, in Erfahrung zu bringen, ob ein Fehler aufgetreten ist oder nicht. Das Polynom Φ ist nur dem Verschlüsselungsgerät bekannt, während die Polynome g und f nur dem Entschlüsselungsgerät bekannt sind, so dass es unmöglich ist, vorherzusagen, ob ein Wrapping-Fehler eintreten wird. Das Erkennen eines Fehlers beinhaltet die Verwendung einer Art Prüf-Hash, welcher die Integrität der ursprünglichen Daten während des Verschlüsselungs-/Entschlüsselungsprozesses bestätigt. Eine solche Prüfung ist auch notwendig, um einige Arten von Angriffen zu verhindern.
Der von Tumbler verwendete Mechanismus zum Erkennen eines Entschlüsselungsfehlers ist in § 6 detailliert beschrieben, und das Mittel zur Korrektur dieser Fehler folgt in § 5.
5. Fehlerkorrektur
Wrapping-Fehler waren zu der Zeit, als das NTRU-Chiffrierverfahren vorgeschlagen wurde (NTRU-Patentanmeldung, § 1.3, S. 31) ein bekanntes Problem. Jedoch war die zu deren Behebung vorgeschlagene Routine fehlerhaft und sie korrigierte nur wenige der auftretenden Wrapping-Fehler. Das Verfahren beinhaltete das Verschieben des Polynoms a von oben um ein Vielfaches von 3. Dies veränderte den Wert des Koeffizienten, welcher inkorrekt gewrapped wurde, so dass er nicht gewrapped war, und veränderte den Wert keines der Koeffizienten, wenn diese modulo 3 reduziert wurden. Leider verursachte dies oft, dass ein Koeffizient, dessen Wert am anderen Ende des Bereiches lag, inkorrekt gewrapped wurde, wo dies zuvor nicht stattgefunden hätte.
Die vorgeschlagene Wrapping-Fehler-Korrektur versagte auch bei der Korrektur eines Fehlers bekannt als Gap-Fehler. Dieser tritt auf, wenn ein falsch gewrappter Koeffizient einen Wert hat, welcher zumindest so nahe an Null ist, wie ein korrekt gewrappter Koeffizient mit dem gleichen Vorzeichen. Dies wurde ursprünglich nicht als Problem angesehen, da man dachte, dass diese Fehler extrem selten seien. Ein Gap-Fehler kann tatsächlich einmal alle zehn Millionen Polynome auftreten, was ausreichend oft ist, um durch viele Anwendungen erkannt zu werden.
Das Prinzip hinter dem Fehlerkorrektursystem von Tumbler ist einfach. Wenn es einen Fehler gibt, dann gilt es diesen zu finden und zu korrigieren.
Die Schwierigkeit ist, dass es N Koeffizienten gibt, welche, naiv gesehen, auf zwei mögliche Arten falsch sein könnten (wenn sie als modulo 3 Werte behandelt werden). Es könnten auch multiple simultane Fehler auftreten. Das Überprüfen jeden möglichen Fehlers ist daher gleichzusetzen mit dem Ausprobieren jedes möglichen ternären Polynoms bis eines funktioniert. Aufgrund der Art des Chiffrierverfahrens würde dies eine unangemessene Zeitspanne in Anspruch nehmen. Ferner wurde der Fehler möglicherweise nicht einmal durch einen Entschlüsselungsfehler verursacht, sondern durch einen Fehler bei der Übertragung oder eine vorsätzliche Änderung durch einen Angreifer.
Die Tumbler-Lösung beruht auf der Tatsache, dass nicht alle Fehler gleich entstehen. Wenn man die möglichen Fehlerursachen von am wahrscheinlichsten zu am wenigsten wahrscheinlich ordnet, dann kann eine extrem effiziente Suche nach der Ursache des Fehlers durchgeführt werden. In der Praxis ist die am häufigsten auftretende Ursache eines Entschlüsselungsfehlers die Ursache für circa 9999 von 10000 Fehlern (für die derzeit in Tumbler verwendete Parameterauswahl).
Rückblickend auf die Ursache des Entschlüsselungsfehlers in § 4 wurden die Algorithmusparameter so gewählt, dass die Koeffizienten eines bestimmten Polynoms nahezu immer innerhalb des Bereiches –q/2 + 1 bis q/2 liegen. Wenn sie nicht innerhalb des Bereiches liegen, so geht man davon aus, dass ein Entschlüsselungsfehler aufgetreten ist. Die Chance, dass ein Koeffizient aus dem Bereich herausfällt, ist in der Praxis etwa 1 in 10000 pro Polynom. Die Chance, dass zwei Koeffizienten gleichzeitig aus diesem Bereich herausfallen, ist geringer als 1 in 100000000 pro Polynom, usw. für mehr gleichzeitige Fehler. Wenn ein Koeffizient aus diesem Bereich herausfällt, dann tut er dies außerdem nahezu immer nur um einen kleinen Betrag. Je größer die Distanz ist, desto weniger wahrscheinlich ist es, dass ein Koeffizient mit dieser Distanz aus dem Bereich herausfällt.
Wenn ferner ein Koeffizient knapp über diesem Bereich liegt, dann wird er zur Untergrenze des Bereiches gewrapped. Wenn ein Koeffizient knapp unter diesem Bereich liegt, wird er zur Obergrenze gewrapped. Im ersten Fall ist sein Wert q zu klein, was bedeutet, dass er x zu klein modulo 3 sein wird, wobei x der kleinste positive Rest von q modulo 3 ist. In letzterem Fall ist er x zu groß.
Dies bietet ein einfaches Mittel zum Aufspüren des Fehlers. Die Werte, die am nächsten zur Ober- und Untergrenze des Bereiches –q/2 + 1 bis q/2 liegen, werden überprüft, und es wird versucht, ihre Werte modulo 3 zu korrigieren, indem x addiert oder subtrahiert wird (je nachdem, ob die Werte an der Unter- bzw. der Obergrenze des Bereiches liegen).
8 zeigt das gleiche Diagramm wie das in 5 (erklärt in § 4). Der die Linie q/2 umgebende Bereich ist hervorgehoben und als 801 markiert. Die Koeffizienten, welche innerhalb dieses Bereiches liegen, sind diejenigen, welche am wahrscheinlichsten einen Fehler verursachen. In der Reihenfolge ihrer Nähe zur Linie q/2 sind die ersten 5 Koeffizienten mit 802, 803, 804, 805 und 806 bezeichnet.
Die wahrscheinlichste Ursache eines Fehlers wäre der mit 802 markierte Koeffizient, welcher einen Wert aufweist, welcher x zu klein ist. Dies ist genau der Fehler, welcher in dem Beispiel in § 4 beschrieben wurde, und das Addieren von x zum Wert dieses Koeffizienten würde den Fehler tatsächlich korrigieren.
Die exakte Methode, welche zum Korrigieren dieser Fehler angewandt werden sollte, hängt stark von der Verwendung ab, für die das Chiffrierverfahren eingesetzt wird, sowie von der Plattform, auf der er implementiert wird. Ein Beispielalgorithmus ist im Folgenden aufgeführt. Die Voraussetzung für diese Methode ist, dass Effizienz erreicht werden kann, indem so schnell wie möglich multiple Korrekturversuche unternommen werden. Es werden jedoch 9999 von 10000 Fehlern bereits beim ersten Versuch korrigiert. In Bezug auf die Geschwindigkeit ist es wahrscheinlich am Besten, in der kürzestmöglichen Zeit eine Prüfung auf den wahrscheinlichsten Fehler durchzuführen, und nur dann die notwendigen Schritte zur Fortsetzung der Suche auszuführen, wenn der erste Versuch fehlschlägt.
Da die Fehler nur in einer Größenordnung von einmal alle 10000 Polynome auftreten, ist der Geschwindigkeitsunterschied im Durchschnitt gering und ist nur von Bedeutung, wenn die konstante Fließgeschwindigkeit von Bedeutung ist. Die hier beschriebene Methode hat einige Vorteile. Wenn angemessene G-Tabellen (siehe unten) zur Verfügung stehen, repariert sie alle Entschlüsselungsfehler in einer angemessenen Zeitspanne. Nach den ersten Schritten können die ursprünglichen Daten in einem sehr effizienten Format gespeichert werden, und auf die ursprünglichen modulo q Daten muss nie wieder Bezug genommen werden.
4 ist ein Flußdiagramm des folgenden Fehlerkorrekturalgorithmus. In der NTRU-Patentanmeldung wurde kein äquivalenter Algorithmus vorgestellt. Dieses Flußdiagramm ist als Ergänzung zu dem Flußdiagramm erstellt, welches das Entschlüsselungssystem beschreibt (siehe 3).

401. Die Fehlerkorrekturroutine verwendet die Algorithmusparameter N und q. Sie verwendet außerdem die Inverse des privaten Schlüssels, F₃, jedoch nicht den privaten Schlüssel selbst. Das Korrekturlevel bestimmt, wie weit die Fehlerkorrekturroutine fortgesetzt werden sollte. Die Fehlerkorrektur muss ungleich null sein, oder die Fehlerkorrekturroutine wäre überhaupt nicht aufgerufen worden. Nahezu alle Fehler werden sehr schnell behoben. Das Korrekturlevel erlaubt es zu kontrollieren, wie sicher man sein kann, dass ein Fehler aufgrund einer Ursache, bei welcher es sich nicht um einen Entschlüsselungsfehler handelt, aufgetreten ist. Ein beliebig hohes Korrekturlevel würde, wenn die Ursache des Fehlers in der Übertragung liegt, dazu führen, dass der Prozess für eine beliebig lange Zeit fortgesetzt wird. Existierende Fehler können sehr wahrscheinlich bereits während der ersten Versuche behoben werden. Daher besteht die Möglichkeit, sehr schnell darauf zu schließen, dass die Chance eines noch nicht entdeckten Fehlers vernachlässigbar ist, und dass der Fehler bei der Entschlüsselung des Polynoms eher von einem Problem verursacht wurde, welches während der Übertragung der Nachricht aufgetreten ist. Die Korrekturroutine übernimmt das halbentschlüsselte mod q Polynom a_i und das chiffrierte Polynom e_i. Diese beziehen sich auf die Polynome, welche durch das Entschlüsselungssystem verwendet werden (siehe 3). e_i wird nur zum Erzeugen des Prüfblocks verwendet. Es besteht die Möglichkeit zu verhindern, e_i immer wieder in die Hash-Instanz eingeben zu müssen, indem der Status der Hash-Funktion nach der Eingabe von e_i aufgezeichnet wird, und dann zu diesem Status zurückzukehren anstelle einer neuen Hash-Instanz, wenn eine neue Prüfung erforderlich ist. Die Tabelle G_jk wird experimentell ermittelt und ermöglicht die Kontrolle der Reihenfolge, in der unterschiedlich viele gleichzeitig auftretende Fehler in verschiedenen Tiefen korrigiert werden. Da nahezu alle Fehler umgehend korrigiert werden, ist es schwer, nach den ersten paar Einträgen ideale Werte für diese Tabelle zu bestimmen. Allein durch diese Tatsache sind die exakten Werte von geringer Bedeutung.
402. Das korrigierte Level ist einfach ein Zähler, welcher zum Vergleich mit dem Korrekturlevel verwendet wird. Der Wert j wird in Verbindung mit der Tabelle G verwendet. Er gibt an, welche Reihe von G derzeit verwendet wird. Der Wert von x gibt an, um wie viel ein Wert, inkorrekt modulo q gewrapped, modulo 3 verändert wurde. Allgemeiner gesprochen, wenn für den Wert von p aus der NTRU-Patentanmeldung ein anderer als 3 gewählt wird, dann wird x wie folgt berechnet x = q rem p.
Das Zentrieren eines Polynoms modulo q bezieht sich auf seine Verschiebung in die am wenigsten absoluten Restklassen (zentriert um Null). Es sei darauf hingewiesen, dass es nicht notwendig ist, den Bereich –q/2 + 1 bis q/2 zu verwenden. Anstelle dessen könnte der Bereich –q/2 bis q/2 – 1 verwendet werden.
403. An dieser Stelle wird eine Liste erzeugt, welche die Koeffizienten von a_i nach der Nähe ihrer Werte zu –q/2 und q/2 ordnet. Wenn Werte, die genau q/2 sind, in Schritt 402 nach unten gewrapped wurden, dann sollten Koeffizienten mit negativem Wert vor Koeffizienten mit positivem Wert mit dem gleichen absoluten Wert aufgelistet werden, und umgekehrt, wenn Werte, die genau –q/2 sind, nach oben gewrapped wurden. In dem in 8 beschriebenen Beispiel würde die Liste mit den Koeffizienten mit der Kennzeichnung 802, 803, 804, 805 und 806 in dieser Reihenfolge beginnen. Es besteht die Möglichkeit, nur den Abstand des Wertes jedes Koeffizienten von der Grenze des Bereiches aufzuzeichnen und nicht den Wert selbst. Hier wird der gesamte Wert verwendet, da es so einfacher ist, dem Prozess zu folgen.
404. Nach der Reduktion modulo 3 wird das ursprüngliche modulo q Polynom a_i nicht mehr verwendet.
405. k wird initialisiert. Dies kontrolliert die Anzahl simultaner Fehler, für die eine Prüfung durchgeführt wird. Als Einstieg wird eine Überprüfung für einen inkorrekt gewrappten Koeffizienten durchgeführt.
406. Hier wird die derzeitige Tiefe, mit der Überprüfungen durchgeführt werden sollten, aus der Tabelle entnommen. Befindet man sich in der ersten Reihe der Tabelle, dann sollte der Prüfvorgang bei Tiefe 0 beginnen. Es sei darauf hingewiesen, dass es, wenn ein Wert nicht größer ist als der für das vorhergehende j, keine ungeprüften k-tupel in 407 gibt, und der Algorithmus springt gleich zum nächsten Wert von k.
407. Der Algorithmus durchsucht alle k-tupel von Koeffizienten mit Werten, welche nicht weiter als eine bestimmte Distanz von ±q/2 entfernt sind. An dieser Stelle wird bestimmt, ob noch k-tupel übrig sind, welche noch nicht überprüft wurden. Ein k-tupel, welches während einer Suche mit einer geringeren Tiefe überprüft wurde, muss nicht noch einmal überprüft werden.
408. Ein k-tupel von Koeffizienten, deren Werte alle innerhalb des gegebenen Bereiches liegen, wird ausgewählt. Dieses k-tupel sollte sich von jedem k-tupel unterscheiden, welches bei einer vorherigen Iteration des Algorithmus ausgewählt wurde. Die Werte des ausgewählten k-tupels werden dann verändert, um für ein möglicherweise falsches Wrapping modulo q modulo 3 zu kompensieren.
409. Unter Verwendung des veränderten a_i' wird der Entschlüsselungsprozess abgeschlossen.
410. Es wird eine Überprüfung durchgeführt, um festzustellen, ob das entschlüsselte Polynom und das Schlüsselpolynom die Integritätsprüfung bestehen.
411. Wird der Integritätstest bestanden, dann wird b_i als das nächste entschlüsselte Polynom akzeptiert.
412. Wenn die möglichen k-tupel aufgebraucht sind, wird die Suche nun auf einen größeren möglichen Abstand von ±q/2 ausgedehnt.
413. Der Wert der Tabelle G bei (j,k) gibt die Tiefe an, bei der die Suche nach einem Fehler in einem k-tupel für den aktuellen Wert von k gestoppt werden soll.
414. Der Zähler, welcher aufzeichnet, wie weit in Bezug auf den beabsichtigten Umfang der Suche gesucht wurde, wird inkrementiert. Es gibt offensichtlich wirtschaftlichere Mittel, um dies zu erreichen, als einen festzugeordneten Zähler.
415. An dieser Stelle wird eine Überprüfung durchgeführt, um festzustellen, ob das korrigierte Level bereits das bereitgestellte Korrekturlevel erreicht hat.
416. Wenn die Überprüfung bis zum spezifizierten Korrekturlevel durchgeführt wurde, ohne bei Stufe 411 mit dem entschlüsselten Polynom angehalten zu haben, dann wird die Suche aufgegeben und das Polynom bleibt unkorrigiert. Realistisch gesehen, geschieht dies mit einem Mindestkorrekturlevel nur dann, wenn der Fehler durch etwas anderes als einen Entschlüsselungsfehler verursacht wird.
417. Die Anzahl simultaner Fehler, für die der Korrekturvorgang durchgeführt werden soll, wird erhöht.
418. Die Reihen von G sind null-terminiert. Wenn ein Ende erreicht wird, wird k zurückgesetzt und die Suche wird für einen Einzelfehler neu gestartet.
419. Der Algorithmus bewegt sich zur nächsten Reihe von G.

Das folgende Beispiel zeigt die Verwendung von Tabelle G detaillierter.
Beispiel

ai = 45 – 117x – 127x2 – 45x3 – 117x4 q/2 = 128

Index 2 entspricht dem Koeffizienten mit dem höchsten absoluten Wert. Die Koeffizienten mit den Indizes 1 und 4 haben den gleichen absoluten Wert und das gleiche Vorzeichen, somit ist es völlig egal, welcher dieser zwei zuerst aufgelistet wird. Für den Rest des Beispiels wird 1 als erstes aufgelistet. Die Indizes 0 und 3 haben den gleichen absoluten Wert und unterschiedliche Vorzeichen, somit wird, unter der Annahme, dass der Bereich –127 bis 128 verwendet wird, 3 zuerst aufgelistet.
Die daraus resultierende Einordnung ist daher {(2,–127), (1,–117), (4,–117), (3,–45), (0,45)}. q = 128 = 3 * 42 + 2. Somit ist x = 2.
In Betracht zu ziehen ist die vereinfachte Tabelle G_jk =
Diese Tabelle gibt die beste Reihenfolge an, in welcher auf Fehler zu prüfen ist. Wenn an einem beliebigen Punkt der Fehler entdeckt und korrigiert wird, dann wird der Prüfvorgang gestoppt.
Der Vorgang beginnt mit einem Versuch, die Einzelfehler zu korrigieren, welche gleich –128 oder 128 sind. Wenn es keine gibt, so fährt er fort mit Einzelfehlern im Bereich –128 bis –127 oder 127 bis 128. Diese Bereiche enthalten einen solchen, wie darauf durch den ersten Index in der Beispieleinordnung verwiesen wird, d.h. 2. Da dieser Koeffizient negativ ist, versucht der Algorithmus, ihn durch Addition von 2 zu korrigieren. Im Sinne dieses Beispiels wird angenommen, dass dies fehlschlägt.
Da G(1,1) = 3, sollte weiterhin versucht werden, Einzelwerte zu korrigieren, bis alle Einzelwerte im Bereich –128 bis –126 oder 126 bis 128 versucht wurden. In diesem Bereich gibt es keine weiteren Einzelwerte.
An dieser Stelle ist es besser zu versuchen, ein Paar zu korrigieren. Jedoch gibt es in dem größten durch G(1,2) = 2 spezifizierten Bereich keine Paare. G(1,3) = 0, und daher muss nun in die nächste Reihe von G gegangen und nochmals mit der Suche nach einem Einzelfehler begonnen werden.
Die Suche beginnt dort, wo sie in der vorhergehenden Reihe aufgehört hat, mit einer Tiefe von 3, und sucht nach Einzelfehlern entlang der Liste nach unten bis zu einer Tiefe von 10. Bei 10 werden zwei weitere potentielle Fehler gefunden. Wieder wird angenommen, dass das Korrigieren dieser Fehler fehlschlägt.
Nun wird ein weiterer Versuch unternommen, ein Fehlerpaar zu korrigieren, dort beginnend, wo die Suche aufgehört hat, bei einer Tiefe von 4. Wenn eine Tiefe 10 erreicht ist, werden drei Koeffizienten in diesem Bereich gefunden und somit 3 potentielle Paare. Da Index 2 der erste in der Liste ist, würden diese Paare in der folgenden Reihenfolge korrigiert werden: (2,1), (2,4) und schließlich (1,4).
Für dieses Beispiel wird angenommen, dass eines dieser Paare tatsächlich die Fehlerursache war. Jedoch ist es wichtig, sich daran zu erinnern, dass in der Praxis ein Fehler nahezu immer bereits mit den ersten Versuchen korrigiert wird.
6. Textbewusstsein
Wenn ein Verschlüsselungssystem in der Lage ist zu bestimmen, ob die verschlüsselten Daten eine gültige Verschlüsselung des dazugehörigen Klartextes sind, dann gilt es als Klartextbewusst. Dies erreicht man üblicherweise mit einer Art Prüf-Hash.
Je nach ihrer Verwendung können Systeme, welche nicht Klartext-bewusst sind, anfällig gegenüber Angriffen sein. Ein Angriff, welcher den Mangel an Bewusstsein eines Systems ausnutzt, funktioniert folgendermaßen:
Ein Angreifer fängt eine verschlüsselte Nachricht ab. Der Angreifer modifiziert dann die verschlüsselte Nachricht leicht, bevor er sie an den ursprünglich beabsichtigten Empfänger weitersendet.
Diese leichte Modifikation kann die Nachricht manchmal in einen ungültigen Chiffriertext umwandeln, d.h. einen, der keine verschlüsselte Form eines beliebigen Klartextes sein könnte. In solchen Fällen ist das Entschlüsselungsgerät nicht in der Lage, die Nachricht zu entschlüsseln und informiert im Allgemeinen den Absender (welcher in diesem Szenarium der Angreifer ist), dass die Nachricht nicht entschlüsselt werden konnte.
Alternativ dazu könnte die modifizierte Nachricht ein gültiger Schlüsseltext sein. In einem solchen Fall entschlüsselt das Entschlüsselungsgerät die Nachricht und versucht sie zu übersetzen. Da sie während der Verschlüsselung modifiziert wurde, ist das Entschlüsselungsgerät möglicherweise nicht in der Lage, den Sinn der Nachricht zu verstehen, dies ist jedoch irrelevant für den Angriff.
Der Angreifer wiederholt diesen Prozess mehrmals, und verzeichnet jedes Mal, welche Modifikationen zu gültigen Chiffriertexten führen. Durch die Analyse dessen ist der Angreifer in der Lage, einen Teil der ursprünglichen Nachricht zu erkennen.
Tumbler verfolgt diesen Ansatz weiter und erzeugt automatisch eine regelmäßige Hash-Prüfung auf Grundlage des Klartextes wie auch des Schlüsseltextes. Dies ermöglicht es uns, Tumbler im Allgemeinen als „Text-bewusst" zu beschreiben.
Tumbler verwendet bevorzugt den SHA-1 (Secure Hash Algorithm 1) zum Berechnen eines Prüf-Hashs für jedes verschlüsselte Polynom. SHA-1 ist im National Institute of Standards and Technology's Secure Hash Standard (FIPS 180-1) der US-Regierung definiert.
Da jedes Nachrichtenpolynom verschlüsselt ist, werden sowohl das ursprüngliche Nachrichtenpolynom als auch das resultierende Chiffrepolynom als Eingabe in eine Instanz des SHA-1 Algorithmus verwendet.
Während der Verschlüsselung wird das Chiffrepolynom zuerst als Eingabe genommen, da dies den Entschlüsselungsprozess im Falle eines Entschlüsselungsfehlers beschleunigt. Das Chiffrepolynom wird zuerst verpackt, um Bytes wie im Folgenden beschrieben, für die Übertragung zu füllen. Die erforderlichen Bits zum Darstellen des ersten Koeffizienten werden am am wenigsten signifikanten Ende des ersten Bytes platziert, usw., und das letzte Byte wird, falls nötig, mit nicht gesetzten Bits abgeschlossen.
Das Nachrichtenpolynom wird dann zum Füllen von Bytes verpackt, wobei diesmal jeder Koeffizient durch zwei Bits dargestellt wird. Beide Bits sind, wenn der entsprechende Koeffizient null ist, nicht gesetzt; wenn der entsprechende Koeffizient –1 ist, ist das erste Bit gesetzt und das zweite ist nicht gesetzt; und wenn der entsprechende Koeffizient 1 ist, dann sind beide Bits gesetzt. Es ist niemals der Fall, dass das zweite Bit gesetzt ist, während das erste nicht gesetzt ist.
Die verpackten Schlüssel- und Nachrichtenpolynome werden verkettet und dann mit Hilfe des SHA-1 Algorithmus gemeinsam gehashed. Die Ausgabe des Hash-Prozesses wird dann (unverschlüsselt) zusammen mit dem Chiffriertext an den Empfänger übertragen.
Normalerweise fügt die Addition des Hashs der Menge des zu übertragenden Textes etwa 20 Bytes hinzu. Es könnten weniger zusätzliche Bytes verwendet werden, jedoch würde dies zu einer geringeren Sicherheit führen.
Beispiel
Das Nachrichtenpolynom {–1,0,1,1} würde als das Byte 10001111 codiert werden.
Das letzte Byte wird, falls nötig, mit nicht gesetzten Bits abgeschlossen. In dieser gepackten Form wird das Polynom mit dem Ende des gepackten Chiffriertextes verkettet, und für die Übertragung an den Empfänger gehashed.
Während der Entschlüsselung werden der Chiffretext und das entschlüsselte Nachrichtenpolynom verkettet und in den SHA-1 eingegeben. Die Ausgabe aus dem SHA-1 wird dann mit dem ursprünglichen Hash verglichen, welcher während des Verschlüsselungsprozesses berechnet und zusammen mit dem Chiffretext empfangen wurde.
Wenn ein Angreifer eine verschlüsselte Nachricht modifiziert ist es daher, selbst wenn die modifizierten Daten entschlüsselt werden können, rechentechnisch nicht praktikabel, dass der Hash der entschlüsselten Nachricht mit dem Hash der ursprünglichen Nachricht übereinstimmt. Dies macht es im Wesentlichen unmöglich, den Schlüsseltext zu verändern und noch immer diesen Test zu bestehen.
Das System weist dann alle Nachrichten ab, deren Hash nicht mit dem Original übereinstimmt, während vorsichtig agiert und der Absender nicht informiert wird, ob der Schlüsseltext gültig war.
Es besteht die Möglichkeit, dass ein Wrapping-Fehler den Fehler im entschlüsselten Nachrichtenpolynom verursacht haben kann. Wenn die Fehlerkorrektur eingeschaltet wird, versucht der Schlüssel, den Fehler zu korrigieren, indem der oben beschriebene Algorithmus verwendet wird. Es ist auf jeder Stufe notwendig, den Prüf-Hash erneut zu berechnen, um zu sehen, ob der Fehler berichtigt wurde. Da der Chiffretext der gleiche bleibt und sich für jede Überprüfung nur das abgerufene Nachrichtenpolynom unterscheidet, ist es möglich, den Chiffretext nur einmal in den Hash einzugeben und das Nachrichtenpolynom jedes Mal einzugeben.
Die allgemeine Methode der Durchführung eines Hash-Prozesses mit dem Chiffretext und dem Klartext zusammen zum Erzeugen eines Integritätstests für beide, ist nicht NTRU-abhängig, sondern funktioniert gleichermaßen gut auch für andere Chiffriertechniken.
7. Mehrfachübertragungen
Tumbler beinhaltet die Option, einen Schutz gegen multiple Übertragungsangriffe (Multiple Transmission Attacks – MTAs) hinzuzufügen.
Sollte die gleiche Nachricht mehr als einmal mit Hilfe des gleichen öffentlichen Schlüssels und ohne den MTA-Schutz verschlüsselt und übertragen werden, kann sie anfällig für Angriffe werden.
Es ist wichtig, sich der Möglichkeit vorhersehbarer Ähnlichkeit zwischen zwei Nachrichten bewusst zu sein. Am offensichtlichsten identifizierbar sind Nachrichten-Header, wie die, welche in einer E-Mail verwendet werden, welche oft vorhersehbar sind. Wenn die ersten Bytes mehrerer Nachrichten identisch sind, dann sind auch ihre ersten Nachrichtenpolynome identisch und daher anfällig für einen MTA.
Angenommen eine Liste von Preisen wird in regelmäßigen Abständen übertragen. Wenn der Angreifer die richtigen Schlüsse zieht, dass sich die Preise nicht verändert haben, würde ihm dies gestatten, einen MTA zu starten.
Die Sicherheit eines einzelnen Nachrichtenpolynoms ist abhängig vom Zufallsfaktor, welcher bei der Verschlüsselung dieses Polynoms verwendet wird. Wenn ein Angreifer in der Lage ist, den Zufallsfaktor zu bestimmen, und Zugriff auf den öffentlichen Schlüssel hat, dann ist es einfach für ihn, die ursprüngliche Nachricht aufzuspüren.
Jedes Mal wenn eine Nachricht gesendet wird, wird der Zufallsfaktor für jedes Polynom zufällig bestimmt. Dies bedeutet, dass, wenn exakt die gleiche Nachricht mehr als einmal gesendet wird, sie einen anderen Zufallsfaktor enthält. Wenn ein Angreifer sicher weiß, dass zwei oder mehr abgefangene Nachrichten exakt den gleichen Klartext haben, dann kann er diese Nachrichten vergleichen, und versuchen, die verwendeten Zufallsfaktoren zu bestimmen.
Selbst ohne MTA-Schutz ist es im Allgemeinen nicht möglich, sämtliche Zufallsfaktoren aus nur zwei Kopien zu bestimmen. Jedoch kann selbst das Senden von nur zwei Kopien die Sicherheit der Nachricht bereits beträchtlich beeinträchtigen, während es das Senden mehrerer Kopien dem Angreifer ermöglichen kann, einen Großteil der (oder sogar die gesamte) Nachricht zu erkennen.
Das Tumbler-MTA-Schutzsystem verwendet eine einfache Datenstromchiffrierung zusammen mit einem zufällig ausgewählten Schlüssel (z.B. mit Hilfe eines Generators. für Pseudo-Zufallszahlen), um sicherzustellen, dass sich die Klartextnachricht zufällig von jeder anderen Nachricht, welche mit dem gleichen Schlüssel gesendet wird; unterscheidet. Die Datenstromchiffrierung erhöht nicht direkt die Sicherheit der Nachricht, da sie mit ihrem Schlüssel übertragen wird, und muss daher keine besonders sichere Chiffrierung sein. Sie muss lediglich sicherstellen, dass sich zwei identische Klartexte in einer unvorhersehbaren Art und Weise voneinander unterscheiden.
Das Verschlüsseln mit der Tumbler-MTA-Schutzoption fügt dem Beginn des Klartextes einen zufälligen (oder pseudo-zufälligen) MTA-Schlüssel hinzu. Dieser Schlüssel wird dann verwendet, um den Anfangsstatus des Tumbler-Sequenzgenerators festzulegen (siehe § 11 und Schritt 202 in 2). Dann werden nachfolgende Bytes von Klartextdaten mit der Ausgabe aus dem Sequenzgenerator XORed, bevor sie in den PKCS-Schlüssel eingegeben werden; siehe Schritt 203 in 2.
Während der Entschlüsselung (3), werden die ersten k Bytes der Daten, welche vom PKCS-Dechiffrierverfahren zurückgesandt werden, verwendet, um den Anfangsstatus des Sequenzgenerators festzulegen (siehe § 11). Nachfolgende Bytes werden mit der Ausgabe aus dem Sequenzgenerator XORed, bevor sie als der entschlüsselte Klartext ausgegeben werden; siehe Schritt 315 in 3.
8. Bits zu Terts
Während Daten üblicherweise als Bits gespeichert werden, behandelt der bevorzugte PKCS-Algorithmus Nachrichten wie Polynome, deren Koeffizienten den Wert 0, 1 oder –1 haben können. Das Nachrichtenpolynom ist lediglich eine Folge ternärer Ziffern (Terts). Es ist ein Verfahren erforderlich, die Bits in Terts und wieder zurück umzuwandeln.
Jeder komplette Satz von 19 Bits der Nachricht wird in der vorliegenden Erfindung in 12 Terts umgewandelt. Dies ergibt eine Packeffizienz von 98,65 %, während es den arithmetischen Operationen, welche bei der Umwandlung verwendet werden, erlaubt, 32-Bit Ganzzahlen zu verwenden. Eine Methode, welche ganze Zahlen mit mehr als 64 Bit verwendet, wäre effizienter, würde jedoch lediglich einen Anstieg der Packeffizienz bedeuten, der im Vergleich zu anderen Packproblemen vernachlässigbar wäre.
8.1 Umwandlung von Bits zu Terts
x sollte als die ganze Zahl ausgewählt werden, deren am wenigsten signifikante 19 Bits in der gleichen Konfiguration gesetzt sind wie der Block aus 19 Bits aus der Nachricht, und deren andere Bits alle auf null gesetzt sind. Hier sollte angenommen werden, dass Terts ganze Zahlen sind, die den Wert 0, 1 oder –1 haben.

1. x wird durch 3 geteilt und der Rest berechnet. Dieser Wert kann dann verwendet werden, um das nächste Tert zu bestimmen. 0 bestimmt, dass der Wert des Terts 0 ist, 1 bestimmt, dass der Wert des Terts 1 ist und 2 bestimmt, dass der Wert des Terts –1 ist.
2. x wird durch 3 geteilt, wobei jeder Rest verworfen wird.
3. Schritt 1 und 2 insgesamt zwölf Mal wiederholen.

Dieser Prozess könnte eindeutig beschleunigt werden, wenn in Schritt 1 x durch 81 anstelle durch 3 geteilt und der Rest dann mit einer Tabelle der 81 möglichen 4-tupel (geordnete Sätze mit vier Elementen) von Terts verwendet werden würde, um die Werte der nächsten vier Terts zu bestimmen. x würde dann in Schritt 2 durch 81 geteilt werden. Wenn dieser Ansatz verwendet werden würde, würde der Prozess nur drei Iterationen anstelle von 12 erfordern.
Eine noch höhere Geschwindigkeit könnte durch eine Methode erreicht werden, bei der x durch 729 geteilt wird, wobei der Rest, unter Verwendung einer Tabelle von 729 möglichen 6-fachen von Terts, genommen wird, um die Werte der nächsten sechs Terts zu bestimmen, und dann x durch 729 zu teilen. Diese Option würde nur einen Rest und eine Divisionsoperation erfordern. Jedoch würde jede Methode, welche eine solche Verbesserung in der Geschwindigkeit bietet, eine entsprechende Steigerung der Code-Größe mit sich bringen. Die ultimative Methode in Bezug auf die Geschwindigkeit würde ein direktes Nachschlagen in einer Tabelle aller 531441 möglichen 12-fachen verwenden.
Egal welche der obengenannten Methoden verwendet wird, der Umwandlungsprozess ergibt Werte im Bereich {0,0,0,0,0,0,0,0,0,0,0,0} bis {–1,0,0,–1,1,0,–1,–1,1,–1,–1,–1}. Somit können nicht alle möglichen 12-fachen von Terts erzeugt werden. Das ist der Fall, weil 3¹² = 531441 größer ist als 2¹⁹ = 524288. Dies ist wichtig, da Sätze von Terts, welche außerhalb dieses Bereiches liegen, verwendet werden, um das Ende der Nachricht zu bezeichnen.
Der letzte unvollständige Satz von 19 Bits wird, wenn vorhanden, mit der erforderlichen Anzahl zufälliger Bits auf 19 Bits aufgefüllt. Die Länge der echten Nachrichtendaten, ausschließlich der Auffüllung, wird vermerkt und zur Bestimmung des Wertes der Nachrichtenendmarkierung verwendet. Für weitere Einzelheiten dazu siehe § 9.
Beispiel
Im Sinne dieses Beispiels sollte angenommen werden, dass die Sequenz von 19 Bits 0101101101001100010 ist, geordnet vom ersten und am wenigsten signifikanten Bit zum letzten und signifikantesten Bit. Betrachtet als eine ganze Dezimalzahl ist diese Bitsequenz 144090. Der Wert jeden Terts kann wie folgt berechnet werden:
Daher wird die Bitsequenz 0101101101001100010 in die Tertsequenz {0,0,–1,–1,–1,1,–1,–1,0,1,–1,0} umgewandelt.
8.2 Umwandlung von Terts in Bits
Nach dem Entschlüsseln erhalten die Daten wieder die Form eines ternären Polynoms, und der Bit-zu-Tert-Umwandlungsprozess muss auf folgende Art und Weise umgekehrt werden:

1. y erhält den Wert von x berechnet aus dem vorherigen Satz von 12 Terts. Dies ist natürlich nicht relevant für den ersten Block, für den es keinen vorhergehenden Satz gibt. x sollte anfangs auf 0 gesetzt sein.
2. Die Terts in dem Satz sollten sequentiell von 0 bis 11 nummeriert werden. Wenn der i^–te Tert 0 ist, wird 0 zu x addiert, wenn er 1 ist, wird 3' zu x addiert, und wenn er –1 ist, wird 2 × 3' zu x addiert.
3. Wenn x nicht mehr als 19 signifikante Bits hat (und daher geringer als 2¹⁹ ist), dann sind die ersten 19 Bits von y die nächsten 19 Bits der ursprünglichen Nachricht. Wenn x mehr als 19 signifikante Bits hat, dann wurde das Ende der ursprünglichen Nachrichtendaten erreicht.

Der Wert von x kann verwendet werden, um exakt zu bestimmen, wie viele der Bits von y Teil der ursprünglichen Nachricht sind und wie viele verworfen werden müssen. Weitere Einzelheiten dazu siehe § 9.
Beispiel
Der Satz von 12 Terts, welche oben berechnet wurden, {0,0,–1,–1,–1,1,–1,–1,0,1,–1,0}, kann wie Folgt in Bits zurückgewandelt werden.
x hat nicht mehr als 19 signifikante Bits (144090 < 2¹⁹) und ist binär durch die 19 Bits 0101101101001100010 dargestellt. Dies sind die gleichen 19 Bits, welche im vorhergehenden Beispiel in Terts umgewandelt wurden.
9. Nachrichtenendmarkierung
Eine binäre Nachricht wird zum Zweck der Verschlüsselung in eine ternäre umgewandelt (siehe § 8). Dies geschieht mit Hilfe von 19-Bit-Blöcken. Natürlich besitzt nicht jede Nachricht eine Länge, die ein exaktes Vielfaches von 19 Bit ist, demzufolge wird, falls nötig, der letzte 19-Bit-Block mit zufälligen Bits aufgefüllt. Diese zufälligen Bits sind nicht Teil der ursprünglichen Nachricht und müssen bei der Entschlüsselung entfernt werden. Die verschlüsselte Nachricht muss daher ausreichende Informationen enthalten, um genau zu bestimmen, welche Bits Teil der Nachricht und welche zu ignorieren sind.
Ferner operiert der Verschlüsselungsmechanismus mit ternären Polynomen mit N Koeffizienten, wobei N ein ganzzahliger Parameter ist, welcher durch die Schlüsselstärke bestimmt wird. Es ist nicht zu erwarten, dass die Nachricht, nachdem sie einmal in ternäre Ziffern umgewandelt wurde, eine exakte Anzahl von Polynomen füllt. Dadurch ist es wahrscheinlich, dass das letzte Polynom auch mit zufälligen ternären Ziffern aufgefüllt werden muss. Wenn die Nachricht entschlüsselt wird, muss es möglich sein, diese Terts zu ignorieren. Der Nachricht wird eine Nachrichtenendmarkierung hinzugefügt, um dem Entschlüsselungsgerät anzuzeigen, wo genau die ursprünglichen Daten aufhören.
Es sei darauf hingewiesen, dass die Methode zur Umwandlung von Bits in Terts niemals ein 12-faches der ternären Ziffern im Bereich {0,1,0,–1,1,0,–1,–1,1,–1,–1,–1} bis {–1,–1,–1,–1,–1,–1,–1,–1,–1,–1,–1,–1} erzeugen wird. Die Werte in diesem Bereich werden alle als Nachrichtenendmarkierungen verwendet.
Wie bereits zuvor angegeben, wird der letzte Block der Nachricht, wenn nötig, auf 19 Bits aufgefüllt und dann in 12 Terts umgewandelt. Unmittelbar im Anschluss an diesen Block wird ein weiterer Satz von 12 Terts als Nachrichtenendmarkierung zur Nachricht hinzugefügt. Die Endmarkierung wird folgendermaßen berechnet:

1. B sollte als eine zufällige ganze Zahl im Bereich 0 – 375 angenommen werden und A als die Zahl des letzten Nachrichten-Bits in dem unvollständigen Satz von 19 Bits.
2. p + 19 x B + 2¹⁹ wird in exakt der gleichen Art und Weise in 12 Terts umgewandelt wie Sätze von 19 Bits zuvor umgewandelt wurden. Die daraus resultierenden Sätze von Terts befinden sich im Bereich {0,1,0,–1,1,0,–1,–1,1,–1,–1,–1} bis {–1,–1,–1,–1,–1,–1,–1,–1,–1,–1,–1,–1}. Dies ist die Nachrichtenendmarkierung. Der Rest des Polynoms wird dann mit zufälligen Terts aufgefüllt.

Natürlich könnten andere Berechnungen verwendet werden, um die Nachrichtenendmarkierung zu erzeugen, vorausgesetzt, dass das Ergebnis eine Reihe von Terts ist, welche außerhalb des möglichen Raumes liegt, welcher verwendet wird, um Nachrichten darzustellen, und dass man aus der Nachrichtenendmarkierung erkennen kann, welches das letzte Bit der Nachricht ist. Eine Möglichkeit dazu ist, den verfügbaren Raum der Nachrichtenendmarkierung in 19 Teile aufzuteilen und eine Markierung aus dem entsprechenden Teil auszuwählen (z.B. zufällig oder im Wesentlichen zufällig), um anzuzeigen, welches der letzten 19 Bits das eigentliche Ende der Nachricht darstellt.
Die Auffüllung des Nachrichtenblocks kann sich am Anfang oder am Ende des Blocks befinden, und die Nachrichtenendmarkierung kann am Anfang oder am Ende des so entstehenden Tertblocks hinzugefügt sein. Die Richtung innerhalb eines Blocks ist mehr oder weniger beliebig, und Ausdrücke wie „gefolgt von" können den Ausdruck „vor" einschließen, wenn der Block in Umkehrung gesehen wird.
Verschlüsselungsbeispiel
Für dieses Beispiel wird angenommen, dass nur noch 4 Bits der ursprünglichen Nachricht zum Verschlüsseln übrig sind, wenn der letzte Block erreicht ist. Unter diesen Umständen werden 15 zufällige Bits ausgewählt und mit den 4 Nachrichten Bits verkettet. Anders ausgedrückt, dass 0^–te, 1^–te, 2^–te und 3^–te Bit dieses Blocks von 19 gehört zur ursprünglichen Nachricht und das 4^–te, ..., 18^–te Bit ist lediglich eine zufällige Auffüllung. A wird daher auf 3 festgelegt, da das 3^–te Bit das letzte Bit ist, welches zu den ursprünglichen Daten gehört. Dieser aufgefüllte Satz von 19 Bits wird dann wie üblich in Terts umgewandelt.
Danach wird eine Nachrichtenendmarkierung ausgewählt. Zuerst wird ein zufälliges B im Bereich 0 – 375 ausgewählt. Für dieses Beispiel erhält B den Wert 122. Dann wird die folgende Berechnung durchgeführt: A + 19 × B + 219 = 3 + 19 × 122 + 219 = 526609.
Die Umwandlung dieser ganzen Zahl in Terts ergibt {1,0,0,1,0,1,–1,0,–1,–1,–1,–1}. Es sei darauf hingewiesen, dass dies größer als {0,1,0,–1,1,0,–1,–1,1,–1,–1,–1} ist, was leicht anhand der Tatsache zu erkennen ist, dass bei dem vorhergehenden 12-tupel alle vier der leitenden Terts (die auf der rechten Seite) auf –1 festgelegt sind, während bei letzterem 12-tupel der vierte Tert 1 ist. {1,0,0,1,0,1,–1,0,–1,–1,–1,–1} ist die erforderliche Endmarkierung.
Beim Entschlüsseln der Nachricht wird jeder Satz von 12 Terts wieder in 19 Bits zurück gewandelt. Wenn die Operation normal verläuft, trifft der Entschlüsselungsprozess schließlich auf einen Block von 12 Terts, welche außerhalb des Bereiches zur Rückwandlung in 19 Bits liegen. Anders ausgedrückt, die durch die Umwandlung zurück ins Binärformat erhaltene ganze Zahl besitzt mehr als 19 signifikante Bits (siehe § 8).
Diese ganze Zahl ist die Nachrichtenendmarkierung. Nach der Umwandlung dieser Nachrichtenendmarkierung zurück ins binäre Format wird 2¹⁹ davon subtrahiert. Das Ergebnis wird durch 19 geteilt und der Rest übernommen. So erhält man wieder A. Von den 19 Bits des Blocks unmittelbar vor der Endmarkierung wird die Bit-Sequenz beginnend mit dem 0^–ten bis zum und einschließlich des A^–ten Bits als ursprüngliche Nachrichten-Bits beibehalten. Die übrigen Bits sind die zufällige Auffüllung, welche zusammen mit möglichen übrigen Terts verworfen werden können.
Entschlüsselungsbeispiel
Für dieses Beispiel wird angenommen, dass der im vorhergehenden Beispiel berechnete Block von 12 Terts {1,0,0,1,0,1,–1,0,–1,–1,–1,–1} gerade während des Entschlüsselungsprozesses empfangen wurde. Wenn diese 12 Terts in die binäre Form zurückgewandelt werden, erhält man den Wert 526609. Dieser ist mindestens genauso groß wie 2¹⁹ (oder anders ausgedrückt, hat mehr als 19 signifikante Bits in seiner binären Darstellung). Das Subtrahieren von 2¹⁹ und die Übernahme des Restes aus der Division durch 19 ergibt den Wert 3. Daraus wird geschlossen, dass das 0^–te, 1^–te, 2^–te und 3^–te Bit des vorhergehenden Blocks von 19 Bits gültige Nachrichten-Bits sind. Die anderen 15 Bits können dann verworfen werden.
Es versteht sich natürlich, dass die Verwendung einer Nachrichtenendmarkierung aus einem zur Nachrichtenübertragung nicht nutzbaren Raum weder auf das oben beschriebene Bit-zu-Tert-Beispiel beschränkt ist, noch ist sie beschränkt auf das spezifische Beispiel von 19 Bits, welche in 12 Terts umgewandelt werden. Andere Umwandlungen, einschließlich einer Änderung des Moduls können verwendet werden, vorausgesetzt es existiert ein geeigneter nicht zugänglicher Raum.
10. Generator für Pseudozufallszahlen
Tumbler bietet zwei Algorithmen zum Generieren von Pseudozufallszahlen (der vorliegende Anmelder erachtet nur den zweiten von beiden als schätzbar). Beide Algorithmen verwenden SHA-1 zum Erzeugen eines unvorhersehbaren und zufällig verteilten Bit-Stromes basierend auf einem Eingabe-Seed.
Es ist wichtig zu bedenken, dass alle Generatoren für Pseudo-Zufallszahlen (PRNGs) an sich deterministisch sind und die erzeugte Ausgabe immer nur so unvorhersehbar sein wird wie der Seed.
Der erste Tumbler-Algorithmus, TSR (Tao SHA-1Random) funktioniert in einer ähnlichen Art und Weise wie viele andere handelsübliche Hash-basierte Verschlüsselungs-PRNGs. SHA-1Random und MDSRandom, bereitgestellt durch RSA und Yarrow, von Counterpane, fallen unter diese Kategorie.
Die Anfangseingabe wird gehashed, und mit dieser Hash-Ausgabe wird wiederholt ein neuer Hash-Prozess mit einem Zähler durchgeführt, um den zufälligen Bit-Strom zu erzeugen. Es ist zu jedem Zeitpunkt möglich, mehr Eingabe hinzuzufügen, welche zusammen mit dem aktuellen Status gehashed wird.
9 zeigt, wie eine vereinfachte Version eines solchen generischen PRNG funktioniert.

901. Ein PRNG muss einen ,Seed' erhalten, oder anders ausgedrückt, er muss einen Anfangsstatus erhalten, auf dem jede nachfolgende Ausgabe basiert. Dies wird durch die Eingabe von Daten erreicht, welche ausreichend unvorhersehbar sind, jedoch kann es zu einem Bitversatz kommen, wodurch sie als Pseudozufallsdaten unbrauchbar werden. Solche Daten erhält man üblicherweise durch Messung von reellen Ereignissen wie dem Timing von Tastenanschlägen oder Mausbewegungen. Diese Daten nennt man Entropie.
902. Eine Hash-Funktion wird verwendet, um eine beliebig große Entropiemenge zusammenzuhashen. Dies ergibt einen internen Status mit definierter Größe, welcher auf dieser Entropie basiert. Die Unvorhersehbarkeit der Entropie ist möglicherweise nicht die gleiche wie ihre Größe. 10 Bit Entropie haben möglicherweise nur 16 mögliche Sammelwerte und haben daher 4 Bit Unvorhersehbarkeit. Mit Hilfe dieses Hash-Schrittes kann man genug Entropie eingeben, um ausreichend Unvorhersehbarkeit zu garantieren.
903. Die Ausgabe von 902 bildet zusammen mit dem Wert des Zählers in 904 den internen Status des PRNG.
904. Ein interner Zähler wird verwendet, um jeden Ausgabeblock zu variieren. Der Zähler ändert sich mit jedem Block zufälliger Ausgabe. Da jeder Ausgabeblock auf dem Zähler basiert, resultiert dies in der Erzeugung unterschiedlicher Ausgaben.
905. Eine weitere Hash-Instanz kombiniert das Ergebnis des ersten Hashes 903 mit dem Zähler 904. Dieser Hash wird jedes Mal wiederverwendet, wenn ein neuer Block zufälliger Daten erforderlich ist.
906. Das Ergebnis des Hashs in 905 sind die pseudozufälligen Daten. Je nach Anwendung kann dies (muss jedoch nicht) eine Folge pseudozufälliger Bits sein.

Es folgt eine genaue Beschreibung von TRS:
H() ist definiert als die Hash-Funktion; X ∥ Y als die Verkettung von X und Y; C als der ganzzahlige Zähler; E; als der i^–te Entropiepool, welcher dem Generator für Zufallszahlen zugefügt wird; P_ij als der j^–te 106-Bit-Pool zufälliger Daten, welcher seit der Eingabe von E_i erzeugt wurde; und S_i als der interne 160-Bit Status, welcher P_ij erzeugt.
Wenn der Algorithmus das erste Mal initialisiert wird, werden der Zähler C, i und j auf Null festgelegt, und alle 160 Bits des Status, So, sind nicht gesetzt.
Wenn der i^–te Entropiepool in den PRNG eingegeben wird, unter der Annahme, dass der aktuelle Status S_(i–1) ist, dann wird der neue Status, Si, zu H(S_(i–1) ∥ E_i).
Wenn mehr Daten erforderlich sind, wird der Zähler C um eins inkrementiert und der neue Pool P_ij wird zu H(S_i ∥ C).
Dieses Verfahren agiert als ein sicherer Mechanismus zum Erzeugen eines unendlichen Verschlüsselungsbitstromes aus der Entropieeingabe, hat jedoch den Nachteil, dass sie nur einen internen Status mit der Größe einer Hash-Ausgabe besitzt. SHA-1 besitzt mit 160 Bits die größte Zuwachsgröße aller derzeit üblicherweise unterstützten Hash-Algorithmen. Dies bedeutet, dass ungeachtet der Menge der Entropieeingabe nicht mehr als 2¹⁶⁰ einzelner Bitströme zwischen Eingabeoperationen erzeugt werden können.
In der modernen Kryptographie ist es oft wünschenswert, dass ein Objekt (wie ein privater Schlüssel) zufällig aus einer extrem großen Menge ausgewählt wird. Zum Beispiel gibt es für N = 503 2⁷²⁰ mögliche NTRU PKCS private Schlüssel. Wenn man einen PRNG mit einem internen Status von 2¹⁶⁰ verwenden würde, und das mit nur einer Seeding-Operation, dann könnten mindestens 2⁵²⁰ der möglichen Schlüssel niemals ausgewählt werden.
Die Durchführung der Seeding-Operationen während der Erzeugung eines Objektes ist nicht immer einfach. Eine Seeding-Operation erfordert Entropie, und Entropie erhält man durch Messung der reellen Welt. Man muss daher genau wissen, wie die Plattform, auf welcher der Schlüssel verwendet wird, mit der reellen Welt interagiert.
Wir beschreiben zwei Lösungen für das Problem, ausreichend zufällige Daten auf eine plattformunabhängige Art und Weise zu erzielen.
Die erste ist ein PRNG, welcher selbst ein „Re-Seed" durchführt. Diese Methode ist recht einfach zu erklären, stellt jedoch eine zusätzliche Anforderung an das System, auf dem er eingesetzt wird, und ist als solcher nur semi-plattformunahängig.
Der interne Grundmechanismus des PRNG bleibt unverändert. Für jede Plattform auf welcher der PRNG arbeiten soll, existiert eine Funktion, welche durch den PRNG aufgerufen werden kann und welche den PRNG mit Entropie versorgt.
Die PRNG erzeugt ganz normal Zufallsdaten, zeichnet aber die Menge der erzeugten Daten auf. Diese wird mit dem internen Status des PRNG sowie mit der Unvorhersehbarkeit der Entropie, welche zuletzt bereitgestellt wurde, verglichen. Wenn der PRNG soviel Daten erzeugt hat wie die kleinere Menge aus dem internen Status und der Unvorhersehbarkeit der Entropie, dann ruft er die plattform-spezifische Funktion auf und fordert mehr Entropie an.
Die zweite Lösung ist komplizierter, hat allerdings den Vorteil, dass sie komplett plattformunabhängig ist.
Das Grundprinzip beinhaltet die Verwendung eines PRNG mit einem sehr großen internen Status. Das Problem bei der Herstellung eines solchen PRNG liegt darin, ihn verschlüsselungstechnisch sicher zu machen, wenn sichere Hashes eine begrenzte Ausgabe haben, welche viel kleiner ist als der erforderliche interne Status.
Tumbler's Implementierung eines PRNG mit großem Status ist der TSR-LS (Tao SHA-1 Random – Large State) Algorithmus (dies ist der zweite der beiden oben erwähnten Tumbler-Algorithmen). TSR-LS verwendet multiple simultane Hash-Funktionen und führt bei jeder neuen Erzeugungsoperation einen neuen Hash-Prozess mit dem ursprünglichen Seed durch. Dadurch erhält er einen internen Status von 2048 Bits, so dass es 2²⁰⁴⁸ einzelne Bit-Ströme gibt, welche zwischen zwei Eingabeoperationen erzeugt werden können. TSR-LS ist langsamer als TSR, jedoch nicht so langsam wie ein PRNG mit dynamischem „Re-Seed".
Ein weiterer Vorteil des TSR-LS gegenüber einem PRNG mit dynamischem „Re-Seed" ist, dass letztgenannter Seed-Daten stückweise verwendet, so dass die Anfangsausgabe nicht von einem Teil des Seeds abhängig ist. Beim TSR-LS ist die gesamte Ausgabe abhängig vom gesamten Seed; jeglicher Unterschied im 2048-Bit-Status besitzt das Potential, jedes Bit der Ausgabe zu verändern.
TSR-LS verwendet ein System mehrrangiger Hash-Funktionen. Eine vereinfachte Version ist in 10 dargestellt. Die Hash-Funktionen können in eine Software eingebettet sein oder, alternativ dazu, können sie Hardware-Hash-Mittel umfassen.

1001. Die Entropie wird zu gleichen Teilen zwischen jeder der Hash-Funktionen im ersten Rang aufgeteilt. Die Anzahl der Hash-Funktionen hängt ab von der erforderlichen Größe des internen Status. Der Seeding-Prozess ist langsamer je mehr Hash-Funktionen verwendet werden, jedoch sind die laufenden Operationszeiten unabhängig von der Anzahl der Hashes.
1002. Zu Beginn hasht jede der Hash-Funktionen im ersten Rang die erhaltene Entropie.
1004. Der Hash des zweiten Ranges übernimmt die Ausgabe aus allen Hashes im ersten Rang 1002 und hasht alles zusammen. Dadurch wird sichergestellt, dass jedes Bit der Endausgabe auf jedem Bit des Anfangs-Seeds basiert.
1005. Die Ausgabe aus dem zweitrangigen Hash 1004 bildet die pseudozufällige Ausgabe für den PRNG. Jedes Mal, wenn von der Anwendung, welche den PRNG verwendet, mehr Daten angefordert werden, führt eine der Hash-Funktionen 1002 (der Reihe nach) unter Verwendung eines Zählers 1003 eine neue Hash-Operation aus. Diese neue Hash-Operation kann die gleiche sein, wie die durch den oben beschriebenen PRNG mit normalem Status verwendete.
1003. Dieser Zähler wird verwendet, um sicherzustellen, dass jede Hash-Funktion mit jeder neuen Hash-Operation eine neue Ausgabe erzeugt. Hier und im folgenden Beispiel wird die Anfangsausgabe als Zählerinkrement verwendet. Jede Hash-Funktion 1002 kann ihren eigenen Zähler 1003 beibehalten.

Die erneut gehashte Ausgabe der bestimmten erneuten Hash-Funktion wir dann in die zweitrangige Funktion 1004 eingegeben, welche diese mit der Ausgabe hasht, die sie zuvor von den anderen Funktionen 1002 erhalten hat, um die erforderlichen neuen Ausgabedaten 1005 zu erzeugen. Auf diese Art und Weise muss nur eine der Funktionen 1002 einen neuen Hash-Prozess durchführen und Daten an die zweitrangige Funktion 1004 weitergeben, wenn eine Anforderung für neue Daten gestellt wird.
Die Hash-Funktionen 1002 erhalten zusätzliche Entropie aus dem Pool 1001, wenn und sobald sie diese benötigen. Alternativ kann zusätzliche Entropie im Block an alle Funktionen 1002 bereitgestellt werden.
Es folgt eine genaue Beschreibung des TSR-LS:
TSR-LS verwendet fünf übereinstimmende Instanzen eines SHA-1 Hash-Objektes. H(), H₀(), H₁(), H₂(), H₃() sind als diese Hash-Funktionen definiert; X ∥ Y wie für TRS oben; C₀, C₁, C₂ und C₃ als vier 160-Bit Zähler; I₀, I₁, I₂ und I₃ als vier 160-Bit Inkremente; E_i als der i^–te Entropiepool hinzugefügt zum Generator für Zufallszahlen; E_i0, E_i1, E_i2, E_i3 als vier Unterentropiepools für jeden Entropiepool E_i; P_ij als der j^–te 106-Bit Pool zufälliger Daten erzeugt seit der Eingabe von E_i; und S_k als der k^–te erzeugte 160-Bit Zwischenstatus.

– Wenn der Algorithmus zuerst initialisiert wird, dann sind bei C₀, C₁, C₂, C₃, I₀, I₁, I₂ und I₃ alle 160 Bits nicht gesetzt, i = 0 und k = –1.
– Wenn der i^–te Entropiepool in den PRNG eingegeben wird, dann wird der Entropiepool E_i so aufgeteilt, dass sich das n-te Byte im Entropie-Unterpool E_ia befindet, wobei a der niedrigste positive Rest von n modulo 4 ist, es sei denn, das Byte ist Teil eines letzten unvollständigen Satzes von 4; in diesem Fall werden die Bits dieses letzten Satzes an Bytes so aufgeteilt, dass das n-te Bit in den Entropieunterpool E_ia eingeschlossen ist, wobei a der niedrigste positive Rest von n modulo 4 ist. Der letzte erzeugte interne Statusblock sollte als S_k definiert werden. Für jede der Hash-Funktionen Ha() wird ein Entropieunterpool mit allen vorherigen, in diesen Hash eingegebenen Daten verkettet. Der Auszug für diese Verkettung wird berechnet und das Ergebnis in S_k+a+1 eingegeben.
– Wenn mehr Daten erforderlich sind, sollte a als der am wenigsten positive Rest von j modulo 4 übernommen werden. C_a wird mit dem Inkrement I_a inkrementiert, indem dieser Wert modulo 2¹⁶⁰ zugefügt wird. Als nächstes wird dieser Wert mit der Eingabe verkettet, welche zuvor durch H_a() gehashed wurde, und das Ergebnis wird berechnet. Es sollte angenommen werden, dass der zuletzt erzeugte interne Statusblock S_k war. In diesem Fall wird das Ergebnis dieses Hashes in S_k+1 eingegeben, und der neue Pool P_ij wird zu H(S₀ ∥ S₁ ∥ ... ∥ S_k+1).

11. Sequenzgenerator
Der Sequenzgenerator wird wie zuvor erläutert für den MTA-Schutz-Hash verwendet. Der Zweck dieses Generators ist es, in einer ähnlichen Art und Weise einen unbegrenzten Strom von Pseudozufallsbits an einen PRNG bereitzustellen, außer dass der Eingabe-Seed bekannt ist und der Strom deterministisch sein muss. Es muss noch immer rechentechnisch unpraktikabel sein, einen Eingabe-Seed zu finden, der eine zufällig ausgewählte Sequenz erzeugt, oder die Eingabe aus jedem beliebigen Teil der Ausgabe zu berechnen.
Da PRNGs deterministisch sind, kann ein Sequenzgenerator erreicht werden, indem ein bekannter Seed an einen spezifizierten PRNG bereitgestellt wird. Bei Tumbler ist ein einfacher Sequenzgenerator bereitgestellt, welcher etwas anders als der PRNG arbeitet (obwohl ein PRNG verwendet werden könnte).
Der Ausgangs-Seed wird mittels einer Instanz des SHA-1 gehashed, und diese Hash-Ausgabe wird wiederum als die ersten 20 Bytes verfügbarer Sequenzdaten verwendet. Danach werden durch Verkettung des vorherigen Ausgabeblocks mit der Hash-Eingabe und der Neuberechnung des Hashes neue Sequenzdaten bereitgestellt.
12. Effiziente Modulo-Arithmetik durch Verwendung paralleler Bit-Operationen auf einer Vektordarstellung
Tumbler verwendet eine neue Methode der Durchführung der Modulo-Arithmetik in kleinen Moduli mittels Bit-basierter Technologie.
Diese Methode erlaubt die Verwendung einer Bit- (d.h. binär) basierten Einrichtung zum effizienten Durchführen der Modulo-Arithmetik. Dies wird durch das Speichern von Zahlen in einer Vektorform und das parallele Ausführen arithmetischer Operationen mit mehreren Zahlen erreicht, unter Verwendung einer einfachen Sequenz bitweiser logischer Operationen. Dies kann verwendet werden, um effiziente Modulo-Arithmetik mit jeder beliebigen Basis durchzuführen.
Jedoch ist die Effizienz mit einer kleinen Basis am größten. Tumbler verwendet diese Methode zum Durchführen von PKCS Ternär-Operationen.
12.1 Detailliertere Beschreibung der Modulo-Arithmetik
Das arithmetische modulo r für eine positive ganzzahlige Basis r betrifft Operationen zwischen den r „Restklassen" von ganzen Zahlen. Eine „Restklasse" besteht aus denjenigen ganzen Zahlen, welche einen gleichen gemeinsamen Rest haben, wenn sie durch r dividiert werden.
Zum Beispiel befinden sich bei modulo 7 64 und 15 in der gleichen Restklasse: 64 = 9 × 7 + 1, 15 = 2 × 7 + 1.
Der Rest beim Dividieren der Summe oder des Produktes von zwei ganzen Zahlen durch jede beliebige ganze Zahl hängt lediglich von dem Rest beim Dividieren der entsprechenden Addenden oder Faktoren durch die gleiche ganze Zahl ab. Es ist daher möglich, Operationen zwischen Restklassen in Betracht zu ziehen.
Addition, Subtraktion und Multiplikation zwischen Restklassen funktionieren auf die gleiche Art und Weise wie bei normaler Ganzzahlenarithmetik zwischen beliebigen ausgewählten Vertretern aus den Restklassen. Normalerweise beinhaltet das Vorhergehende das Auswählen eines Satzes von Vertretern, einer aus jeder Restklasse. Diese wären normalerweise entweder der Satz mit dem kleinsten positiven Wert (d.h. {0, 1, ..., r–1}), oder der Satz mit dem niedrigsten absoluten Wert {[–r/2] + 1, ..., 0, ..., [r/2]}.
Modulo-Arithmetik ist theoretisch viel einfacher als generalisierte Ganzzahlenarithmetik. Jedoch sind moderne digitale Geräte so ausgelegt, dass sie mit generalisierter Ganzzahlenarithmetik zurechtkommen, und zwar so, dass sie bei der Durchführung von Modulo-Arithmetik sehr ineffizient sind.
12.2 Gerätevoraussetzungen
Künftig wird angenommen, dass ein Gerät existiert, welches n-Bit Wörter verwendet und in der Lage ist, die folgenden bitweisen logischen Operationen auszuführen:

– Die Binäroperation XOR so definiert, dass sie ein Wort wiedergibt, von dem jedes Bit gesetzt ist, wenn, und nur wenn die entsprechenden Bits beider Eingabewörter weder beide gesetzt noch beide ungesetzt sind.
– Die Binäroperation AND so definiert, dass sie ein Wort wiedergibt, von dem jedes Bit festgelegt ist, wenn, und nur wenn die entsprechenden Bits beider Eingabewörter gesetzt sind.
– Die Binäroperation OR so definiert, dass sie ein Wort wiedergibt, von dem jedes Bit gesetzt ist, wenn, und nur wenn die entsprechenden Bits eines oder beider Eingabewörter gesetzt sind.
– Die Unäroperation NOT so definiert, dass sie ein Wort wiedergibt, von dem jedes Bit gesetzt ist, wenn, und nur wenn das entsprechende Bit des Eingabewortes ungesetzt ist.

12.3 Vektordarstellung
Der Haken an der hier beschriebenen Methode liegt in der bitweisen Vektordarstellung von Zahlen.
Digitale Geräte speichern normalerweise ganze Zahlen in binärer Form in den benachbarten Bits eines Wortes. Dadurch wird die Verwendung von Schaltkreisen wie „Halbaddierern" zugelassen, welche einen Übertrag zwischen Bits zulassen. Bei einer Vektordarstellung wird der Wert einer Zahl durch Bits dargestellt, welche sich an entsprechenden Stellen innerhalb unterschiedlicher Wörter befinden. Der Wert dieser Bits muss nicht in Bezug zu der binären Form der Zahl stehen.
Die Interpretation der Bits in einer neuartigen Art und Weise, wie im späteren Beispiel mit ternären Zahlen veranschaulicht, kann zu einer höheren Effizienz sowie weiteren damit verbundenen Vorteilen führen.
Die Ausführung einer einzelnen Modulo-Arithmetik-Operation zwischen zwei ganzen Zahlen ist wesentlich weniger effizient bei Verwendung der Vektordarstellung als bei Verwendung normaler Ganzzahlenmethoden. Dies ist der Fall, da die Kombination der 2x[log₂ r] Wörter, welche die Zahlen darstellen, im Allgemeinen O(log₃ r)-Operationen beinhalten.
Der Anmelder hat jedoch erkannt, dass der Vorteil einer Vektordarstellung in ihrer unbegrenzten Parallelisierbarkeit liegt. Die Anzahl identischer Operationen, welche gleichzeitig ausgeführt werden können, ist nur durch die Wortlänge begrenzt.
12.4 Ternärdarstellung
Künftig wird angenommen, dass die drei möglichen Werte eines Terts (Darstellungen einer Ternärzahl) null, eins und minus eins sind. Dies ist eine willkürliche Entscheidung und das System gilt unabhängig von den Namen der drei Terts.
Die Terts werden durch zwei Bits dargestellt, welche sich an entsprechenden Stellen in zwei einzelnen Wörtern befinden. Das Bit, welches sich in dem ersten Wort befindet, ist gesetzt, wenn und nur wenn der Wert des Terts nicht null ist. Das Bit, welches sich in dem zweiten Wort befindet, ist gesetzt, wenn und nur wenn der Wert des Terts eins ist. Daher werden die drei Terts 0, 1 und –1 durch die Vektoren <0,0>, <1,1> bzw. <1,0> dargestellt. Auf diese Art und Weise können n Terts in zwei n-Bit Wörtern dargestellt werden.
Beispiel
Angenommen wir möchten bitweise Vektordarstellungen der vier Terts 0, 0, –1 und 1 verwenden. Die Verwendung der oben spezifizierten Vektoren ergibt die folgende
Tabelle:
Nun werden das 1. Bit und das 2. Bit genommen und separat gespeichert, was es uns erlaubt, diese Informationen als zwei separate 4-Bit-Wörter, nämlich 0011 (als Darstellung des 1. Bits) und 0001 (als Darstellung des 2. Bits) zu behandeln. Dann kann Modulo-Arithmetik nicht auf die individuellen Terts oder die Vektoren angewandt werden, sondern auf die Wörter selbst, zum Beispiel mit Hilfe der Operationen XOR, AND, OR und NOT. Dies verhindert, dass wir uns mit Überläufen oder Überträgen beschäftigen müssen, egal an wie vielen Terts gleichzeitig gearbeitet wird.
Abgesehen von der Empfehlung einer effizienten Methode zur Ausführung von Modulo-Arithmetik erlaubt diese Interpretation der Bits die Bestimmung des Wertes eines Terts modulo 2, indem einfach das erste Array untersucht wird. Da Algorithmen oft mit der Unterscheidung von null und nicht-null Terts zu tun haben, hat diese Methode einen großen Vorteil gegenüber der üblichen Binärform.
Wenn es ein Paar entsprechender Bits gibt, und das im ersten Wort befindliche Bit ungesetzt ist, dann ist das im zweiten Wort befindliche Bit nie gesetzt. Jedoch muss sich das System nicht darauf stützen.
Natürlich können für Modulo-Arithmetik auf einer Basis ungleich 3 ähnliche Prinzipien gelten – zum Beispiel würde man zum Ausführen von Arithmetik in Basis 5 an drei separaten Wörtern arbeiten, wobei das erste alle ersten Bits in der Vektordarstellung darstellt, das zweite alle zweiten Bits und das Dritte alle dritten Bits. Der Ansatz würde auch für eine höhere Basis funktionieren.
12.5 Modulo-Drei-Arithmetik
Modulo-Drei-Arithmetik wird auf folgende Art und Weise ausgeführt.
X_~0 und X₁ sind die zwei n-Bit-Wörter, welche die n Terts x₀, ... x_n–1 darstellen, wobei das Wort X_~0 den Bit-Satz enthält, wenn der entsprechende Tert nicht null ist, und das Wort X₁ enthält den Bit-Satz, wenn der entsprechende Tert eins ist. Ähnlich sind Y_~0 und Y₁ die zwei n-Bit-Wörter, welche die n Terts y₀, ... y_n–1 darstellen.
Das Ergebnis der Addition der n Tert-Paare (x_i y_i), jeweils modulo 3, wobei i = 0 bis (n – 1) ist, zum Erzeugen von Z_~0 und Z₁, welche die Terts x₀ + y₀ (mod 3), ..., x_n–1 + y_n–1 (mod 3) darstellen, kann dann wie Folgt berechnet werden: Z1 = (X~0 XOR Y1) AND (X1 XOR Y~0), Z~0 = (X~0 XOR Y~0) OR (X1 AND Y1) OR Z1.
Das Ergebnis der Subtraktion des Wertes von y_i von x_i, jeweils modulo 3, wobei i = 0 bis (n – 1) ist, zum Erzeugen von Z_~0 und Z₁, welche die Terts x₀ – y₀ (mod 3), ... x_n–1 – y_n–1 (mod 3) darstellen, kann wie Folgt berechnet werden: Z~0 = (X~0 XOR Y~0) OR (X1 XOR Y1), Z1 = (Y~0 XOR X1) AND ((NOT Y1) OR X~0) AND Z~0.
Das Ergebnis der Multiplikation der n Tert-Paare (x_i y_i), jeweils modulo 3, wobei i = 0 bis (n – 1) ist, zum Erzeugen von Z_~0 und Z₁, welche die Terts x₀ x y₀ (mod 3), ..., x_n–1 x y_n–1 (mod 3) darstellen, kann wie Folgt berechnet werden: Z~0 = (X~0 AND Y~0), Z1 = (NOT (X1 XOR Y1)) AND Z~0.
Im Feld F₃ sind die einzigen beiden nicht-null Elemente, 1 und –1, beide selbstumkehrend. Daher lässt sich die Division nicht von der Multiplikation unterscheiden.
12.6 Hardware und Software
Diese Methode ist einfach in Hardware zu implementieren, wie dies durch die in 11, 12 und 13 gezeigten Schaltpläne illustriert ist. 11 zeigt einen Schaltplan für Addition modulo 3, 12 zeigt einen Schaltplan für Subtraktion modulo 3 und 13 zeigt einen Schaltplan für Multiplikation modulo 3.
Bei Software ermöglicht diese Methode skalierbare Parallelisierung, da man in der Lage ist, die volle Breite eines Wortes egal welcher Länge auszunutzen.
12.7 Verwendung in Tumbler
Das Tumbler-PKCS verwendet modulo 3 Polynome, d.h. Polynome, deren Koeffizienten alle Werte haben, welche nur signifikant modulo 3 sind. Auf verschiedenen Stufen im Algorithmus ist es notwendig, diese Polynome zueinander zu addieren und voneinander zu subtrahieren. Spezifisch verwendet die aktuelle Implementierung des Schlüsselerzeugungssystems den „Almost Inverse Algorithmus" (siehe § 3) oder alternativ dazu den Euklid-Algorithmus, angewandt auf modulo 3 Polynome. Diese Algorithmen erfordern abwechselnd die Addition und Subtraktion von Polynomen. Das Entschlüsselungssystem erfordert das Faltungsprodukt (Sternmultiplikation) von zwei modulo 3 Polynomen. Der Sternmultiplikationsalgorithmus verwendet auch die Addition und Subtraktion von Polynomen.
Zur Addition von zwei Polynomen addiert man die Werte der entsprechenden Koeffizienten aus jedem der Polynome. Der Wert des ersten Koeffizienten aus dem ersten Polynom wird zum Wert des ersten Koeffizienten des zweiten Polynoms hinzuaddiert, um den Wert des ersten Koeffizienten der Summe zu erzeugen, und so weiter.
Wenn das erste Polynom wie zuvor beschrieben als das Zwei-Bit-Array X₁ und X_~0 dargestellt wird und das zweite Polynom wird als das Zwei-Bit-Array Y₁ und Y_~0 dargestellt, dann kann die Polynomsumme der zwei Polynome berechnet werden, indem die folgende modulo 3 Additionsoperationen an den vier Arrays ausgeführt werden. Z1 = (X~0 XOR Y1) AND (X1 XOR Y~0), Z~0 = (X~0 XOR Y~0) OR (X1 AND Y1) OR Z1.
Das Gleiche gilt für die Subtraktion. Die Speicherung jeden Polynoms als Zwei-Bit-Array erlaubt die Verwendung der oben genannten Subtraktionsmethode zur Berechnung der Differenz der beiden Polynome.
Da jedes Polynom in Tumbler bis zu 503 Koeffizienten aufweisen kann, erzeugt diese Methode eine erhebliche Erhöhung der Geschwindigkeit.
Dieser Ansatz für die Modularithmetik kann im Bereich digitaler Datenverarbeitung im Allgemeinen Anwendung finden und ist nicht auf die Verwendung innerhalb von Verschlüsselungssystemen beschränkt.

Claims

Generator für Pseudo-Zufallszahlen, der folgendes umfasst: (a) mehrere erstrangige Hash-Mittel (1002), von denen jedes eine Entropieeingabe erhalten und eine entsprechende Hash-Ausgabe erzeugen kann, (b) ein zweitrangiges Hash-Mittel (1004), das dafür ausgelegt ist, als Eingabe alle entsprechenden erstrangigen Hash-Ausgaben anzunehmen, und als Ausgabe (1005) eine Pseudo-Zufallszahl zu erzeugen, die auf allen jeweiligen erstrangigen Hash-Ausgaben beruht.
Generator für Pseudo-Züfallszahlen nach Anspruch 1, dadurch gekennzeichnet, dass jedes erstrangige Hash-Mittel dafür ausgelegt ist, zusätzliche Entropieeingaben zu erfordern.
Generator für Pseudo-Zufallszahlen nach Anspruch 1 oder Anspruch 2, dadurch gekennzeichnet, dass eines der erstrangigen Hash-Mittel dafür ausgelegt ist, einen neuen Hash-Prozess auszuführen, um eine neue Hash-Ausgabe zu erzeugen, wenn eine weitere Pseudo-Zufallszahl benötigt wird, wobei die vorerwähnte neue Hash-Ausgabe dem zweitrangigen Hash-Mittel zugeführt wird, das dieses zur Erzeugung der weiteren Pseudo-Zufallszahl verwendet.
Generator für Pseudo-Zufallszahlen nach Anspruch 3, dadurch gekennzeichnet, dass er ein Zählmittel enthält, das dafür ausgelegt ist, dem vorerwähnten erstrangigen Hash-Mittel weitere Eingaben zu liefern, wobei die weiteren Eingaben in den neuen Hash-Prozess einbezogen werden.
Generator für Pseudo-Zufallszahlen nach Anspruch 3 oder Anspruch 4, dadurch gekennzeichnet, dass das vorerwähnte erstrangige Hash-Mittel dafür ausgelegt ist, die vorherige Hash-Ausgabe (1003) als Teil des neuen Hash-Prozesses einzuschließen.
Generator für Pseudo-Zufallszahlen nach einem der Ansprüche 3 bis 5, dadurch gekennzeichnet, dass das vorerwähnte erstrangige Hash-Mittel sich ändert, sobald eine weitere Pseudo-Zufallszahl erzeugt werden soll.
Generator für Pseudo-Zufallszahlen nach Anspruch 6, dadurch gekennzeichnet, dass das vorerwähnte eine erstrangige Hash-Mittel der Reihe nach aus der Zahl der erstrangigen Hash-Mittel ausgewählt wird.
Generator für Pseudo-Zufallszahlen nach Anspruch 4, dadurch gekennzeichnet, dass jedes vorerwähnte erstrangige Hash-Mittel mit einem entsprechenden Zählmittel verbunden ist.
Generator für Pseudo-Zufallszahlen nach einem der Ansprüche 1 bis 8, dadurch gekennzeichnet, dass jedes Hash-Mittel als Software-Hash-Funktionsobjekt ausgebildet ist.
Generator für Pseudo-Zufallszahlen nach einem der Ansprüche 1 bis 9, dadurch gekennzeichnet, dass er einen Entropiepool 1001 zur Lieferung von Entropie an die erstrangigen Hash-Mittel enthält.
Generator für Pseudo-Zufallszahlen nach Anspruch 10, dadurch gekennzeichnet, dass der Entropiepool in Unterpools aufgeteilt ist, von denen jeder dafür ausgelegt ist, Entropie an ein jeweiliges erstrangiges Hash-Mittel zu liefern.
Verfahren zur Generierung von Pseudo-Zufallszahlen, das folgendes aufweist: (a) Lieferung einer Entropieeingabe an mehrere erstrangige Hash-Funktionen (1002) und Erzeugung einer jeweiligen Vielzahl von Hash-Ausgaben, (b) Lieferung der vorerwähnten Vielzahl von Hash-Ausgaben als Eingaben an eine zweitrangige Hash-Funktion (1004), die als Ausgabe eine Pseudo-Zufallszahl liefert, welche aus allen jeweiligen erstrangigen Hash-Ausgaben beruht.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 12, dadurch gekennzeichnet, dass es die Lieferung von zusätzlicher Entropie an die erstrangigen Hash-Funktionen aufweist.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 12 oder Anspruch 13, dadurch gekennzeichnet, dass es wenn eine neue Pseudo-Zufallszahl benötigt wird, die Durchführung eines neuen Hash-Prozesses mit einer der erstrangigen Hash-Funktionen, um eine neue Hash-Ausgabe zu erzeugen, und die Weiterleitung der vorerwähnten neuen Hash-Ausgabe an die zweitrangige Hash-Funktion aufweist, die dieselbe bei der Erzeugung der neuen Pseudo-Zufallszahl verwendet.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 14, dadurch gekennzeichnet, dass es die Lieferung eines Zählwertes als zusätzliche Eingabe in die vorerwähnte eine erstrangige Hash-Funktion enthält, wobei die zusätzliche Eingabe in den neuen Hash-Prozess einbezogen wird.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 14 oder Anspruch 15, dadurch gekennzeichnet, dass die vorerwähnte eine erstrangige Hash-Funktion als Teil des neuen Hash-Prozesses die vorherige Haus-Ausgabe (1003) verwendet.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach einem der Ansprüche 14 bis 16, dadurch gekennzeichnet, dass sich die vorerwähnte eine erstrangige Hash-Funktion ändert, sobald eine weitere Pseudo-Zufallszahl erzeugt werden soll.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 17, dadurch gekennzeichnet, dass sie die Wahl der vorerwähnten einen erstrangigen Hash-Funktion der Reihe nach aus der Vielzahl von erstrangigen Hash-Funktionen enthält.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 15, dadurch gekennzeichnet, dass darin ein jeweiliger Zählwert der jeweiligen erstrangigen Hash-Funktion zugeführt wird, sobald ein neuer Hash-Prozess erforderlich ist.
Computerprogramm zur Generierung von Pseudo-Zufallszahlen, das beim Lauf auf einem Computer die in einem der Ansprüche 12 bis 15 dargelegten Schritte des Verfahrens ausführt.
Maschinenlesbares Medium, das ein Computerprogramm nach Anspruch 20 enthält.
Datenstrom, der repräsentativ für ein Computerprogramm nach Anspruch 20 ist.
Generator für Pseudo-Zufallszahlen nach Anspruch 3, dadurch gekennzeichnet, dass das zweitrangige Hash-Mittel bei Erzeugung einer weiteren Pseudo-Zufallszahl als Eingabe die Hash-Ausgaben enthält, die vorher von den erstrangigen Hash-Mitteln, die von dem vorerwähnten einen erstrangigen Hash-Mittel verschieden sind, erzeugt wurden.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 23, dadurch gekennzeichnet, dass die vorherigen Hash-Ausgaben und die neue Hash-Ausgabe für die Verwendung als Eingabe an das zweitrangige Hash-Mittel verkettet werden.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 14, dadurch gekennzeichnet, dass die zweitrangige Hash-Funktion beim Erzeugen einer weiteren Pseudo-Zufallszahl als Eingabe auch die Hash-Ausgaben enthält, die vorher von der erstrangigen Hash-Funktion, welche von der vorerwähnten einen erstrangigen Hash-Funktion verschieden ist, erzeugt wurde.
Verfahren zur Generierung von Pseudo-Zufallszahlen nach Anspruch 25, dadurch gekennzeichnet, dass die vorherigen Hash-Ausgaben und die neue Hash-Ausgabe für die Verwendung als Eingabe an die zweitrangige Hash-Funktion verkettet werden.