Das Knapsack-Kryptosystem

Transkript

1 Das Knapsack-Kryptosystem Frank Hellweg 21. Februar Einleitung Das Knapsack-Kryptosystem wurde 1978 von den amerikanischen Kryptologen Martin Hellman und Ralph Merkle entwickelt [MH78] und war eines der ersten Public-Key-Kryptosysteme. Wegen seiner Unkompliziertheit (z.b. müssen im Gegensatz zum RSA-System keine großen Primzahlen gesucht werden) erfreute es sich anfangs großer Beliebtheit. Andere Kryptologen wiesen allerdings schon von Beginn an darauf hin, dass das Verfahren möglicherweise nicht sicher sei; beweisen konnte dies jedoch erst Adi Shamir, der 1982 das originale System von Merkle und Hellman brechen konnte [S82]. In der Folge gab es eine Vielzahl von ähnlichen Kryptosystemen, jedoch konnten bis auf eine, das Chor-Rivest-Kryptosystem [CR88], alle Varianten der Rucksackkryptographie gebrochen werden. Diese Ausarbeitung befasst sich mit dem von Merkle und Hellman stammende Originalsystem, der vorgestellte L 3 - Angriff funktioniert aber auch mit anderen Knapsack-Systemen. 2 Grundlagen 2.1 Das Subset-Sum-Problem Das Knapsack-Kryptosystem beruht auf dem mathematischen Problem Subset- Sum, das einen Spezialfall des Rucksackproblems (engl. Knapsack, daher auch der Name des Kryptosystems) darstellt: Definition 1 (Subset-Sum). Seien S, n N, a N n. Gesucht ist ein Vektor x {0, 1} n, so dass a x = S. Mit anderen Worten: Wir suchen für eine gegebene Summe S und einen Vektor a aus positiven ganzen Zahlen eine Auswahl dieser Zahlen, die aufsummiert genau S ergibt. Eine 1 im i-ten Element des Vektors x bedeutet dabei, dass die i-te Zahl in die Summe einbezogen wird, eine 0, dass sie in der Summe nicht enthalten ist. Vom Subset-Sum-Problem wird angenommen, dass es sich deterministisch im Allgemeinen nicht in polynomieller Zeit lösen lässt. Eine Reduktion von 3-SAT 1

2 auf Subset-Sum wird in [CLRS01] angegeben. Wie wir gleich sehen werden, betrachten wir jedoch nur eine bestimmte Unterklasse von Problemen. Im folgenden werde ich ein Tupel (a, S) aus Vektor a und Summe S kurz Knapsack nennen. Definition 2. Sei a N n. Dann heißt a extra simpel, falls für alle 1 i n gilt: a j < a i Wir setzen also voraus, dass jedes Element des Vektors echt größer ist als die Summe aller vorhergehenden Elemente. Beispiel. Der Vektor a = (1, 2, 4, 8) ist extra simpel, da 2 > 1, 4 > = 3, 8 > = 7. Nebenbei sei erwähnt, dass das Lösen des Knapsacks (a, S) für ein beliebiges S dem Finden einer vierstelligen Binärdarstellung von S entspricht. Außerdem fällt auf, dass es sich bei a um den kleinsten extra simplen Vektor mit vier Stellen handelt, denn für 1 i n gilt: a j = a i 1. Satz 1. Ein Knapsack (a, S) {(c, K) c Z n >0, S Z >0 } lässt sich in polynomieller Zeit lösen, falls a extra simpel ist. Beweis: Betrachte Algorithmus 1. Algorithmus 1 1: function KnapsackGreedy(a, S) 2: for i n downto 1 do 3: if a[i] S then 4: x[i] 1 5: S S a[i] 6: else 7: x[i] 0 8: return x Der Algorithmus durchläuft den übergebenen Vektor a von hinten nach vorne, d.h. vom größten zum kleinsten Element. Ist das aktuelle Element a i kleiner oder gleich der Restsumme S, dann wird das entsprechende Bit x i im Ergebnisvektor x auf 1 gesetzt und die Restsumme um a i verringert. Andernfalls wird das entsprechende Ergebnisbit auf 0 gesetzt. Lemma 1. Algorithmus 1 hat polynomielle Laufzeit. Beweis: Der Algorithmus beinhaltet nur eine Schleife, die n mal durchlaufen wird. Im Inneren dieser Schleife werden nur Vergleiche und Divisionen ausgeführt, weswegen wir bei kleinen Zahlen eine worst-case-laufzeit von O(n) erhalten, bei großen Zahlen, für die Vergleiche und Divisionen nicht als einfache Prozessoroperationen durchführbar sind, eine worst-case-laufzeit von O(n 2

3 log m), in Abhängigkeit von der größten beteiligten Zahl m. Die ermittelte Laufzeit ist polynomiell. Lemma 2. Falls a extra simpel ist, kann der Knapsack (a, S) höchstens eine Lösung haben. Gibt es eine solche, so ermittelt Algorithmus 1 sie. Beweis: Sei x die Ausgabe des Algorithmus. Wir nehmen an, x sei keine korrekte Lösung des Knapsacks (a, S). Vorausgesetzt, (a, S) hat eine Lösung, gibt es y {0, 1} n mit a y = S, d.h. y ist Lösung von (a, S) und y x. Betrachte nun i = max{j x j y j }. Es gilt K i := i<j n a j x j = i<j n a j y j, da i die am weitesten rechts stehende Stelle ist, an der sich x und y unterscheiden. Außerdem ist S K i gleich dem Rest der Summe S im Iterationsschritt i. Wir unterscheiden zwei Fälle: Fall 1: x i = 1, y i = 0. Da x i = 1, muss laut Algorithmus S K i a i gelten. Da a extra simpel ist, gilt: a j < a i S K i = = = y ist keine Lösung von (a, S) a j y j + 0 a i a j y j + 0 a i + K i < S K i = y a < S Fall 2: x i = 0, y i = 1. Da x i = 0, muss laut Algorithmus S K i < a i gelten. = = y ist keine Lösung von (a, S) = 1 a i + K i > S a j y j + 1 a i + K i = y a > S Aus Fall 1 und 2 folgt, dass x Lösung von (a, S) ist. Der Beweis, dass x die einzige Lösung von (a, S) ist, folgt analog. Korrolar: Aus Lemma 1 und Lemma 2 folgt die Korrektheit von Satz 1. 3

4 3 Funktionsweise Wir kennen nun ein NP-schweres Problem, Subset-Sum, und eine Teilmenge von Problemen, die wir in polynomieller Zeit lösen können, nämlich die auf extra simplen Vektoren basierenden Subset-Sum-Probleme. Diesen Umstand können wir für ein asymmetrisches Kryptosystem nutzen, indem wir privat einen extra simplen Knapsack nutzen, diesen aber nur nach Verstecken seiner Eigenschaften als öffentlichen Schlüssel freigeben. Dieses Verstecken werden wir durch eine modulare Multiplikation des extra simplen Vektors erreichen. 3.1 Initialisierung Zum Initialisieren des Knapsack-Systems sind folgende Schritte nötig: 1. Wähle extra simplen Vektor a Z n >0 2. Wähle Modul m mit m > 1 i n a i 3. Wähle w Z m mit ggt (m, w) = 1 4. Berechne w 1 mod m 5. Berechne a = a w mod m 6. Veröffentliche a als public key; behalte a, w, w 1 und m als private key. Beispiel. Wähle a = (1, 4, 6, 15), m = 30. Wähle außerdem w = 7 mit w 1 13 mod m. Dann ist a = w a (7, 28, 12, 15). Laufzeit: Zum Berechnen von w 1 kann der erweiterte euklidische Algorithmus angewendet werden. Dieser hat eine Laufzeit von O(log 2 m), d.h. quadratisch zur Länge der eingegebenen Zahlen. Für das Ermitteln der restlichen Werte ist eine Laufzeit von höchstens O(n log 2 m) anzusetzen. Da n log 2 m, ergibt sich eine Gesamtlaufzeit von O(log 3 m). 3.2 Chiffrierung Sobald der öffentliche Schlüssel bekannt ist, können wir mit seiner Hilfe eine Nachricht verschlüsseln: 1. Teile die zu verschlüsselnde Nachricht in Blöcke der Größe n Bits auf 2. Berechne für jeden Block b {0, 1} n die Summe S = a b = 1 i n a i b i. 3. Gib S weiter. Beispiel(Fortsetzung). Wir wollen die Nachricht b = (1, 1, 0, 1) verschlüsseln. Dazu berechnen wir S = a b = = 50. Laufzeit: Bei der Chiffrierung müssen wir für Pakete der Größe n jeweils O(n) Additionen durchführen, die jeweils eine Laufzeit von O(log m) haben. Es ergibt sich also eine Laufzeit von O(n log m) = O(log 2 m). 4

5 3.3 Dechiffrierung Erhält der Besitzer des privaten Schlüssels eine wie oben beschrieben chiffrierte Nachricht S, ergibt sich der zugehörige Klartext wie folgt: 1. Berechne S = S w 1 mod m. 2. Löse den Knapsack (a, S ). Da a extra simpel ist, können wir zum Lösen des Knapsacks (a, S) die Funktion KnapsackGreedy (siehe Algorithmus 1) verwenden. Beispiel(Fortsetzung). Um S zu dechiffrieren, berechnen wir S w 1 = = mod 30. Für den so erhaltenen Knapsack (a, 20) mit a = (1, 4, 6, 15) liefert uns KnapsackGreedy den Vektor x = (1, 0, 1, 1) als Lösung. Das entspricht dem oben chiffrierten Klartextvektor b. Laufzeit: Im ersten Schritt führen wir eine Multiplikation und eine Division durch, was eine Laufzeit von O(log 2 m) ergibt. Der KnapsackGreedy-Algorithmus hat hier eine Laufzeit von O(n log m), da m die größte Zahl der Eingabe ist. Das führt zu einer Gesamtlaufzeit von O(n log m + log 2 m) = O(log 2 m). Satz 2. Der Algorithmus arbeitet korrekt, d.h. als Lösung des Knapsacks (a, S ) erhält man b. Beweis: Zu zeigen ist: a b = S = a b = S und b ist die einzige Lösung von (a, S ). a b = S = a b S mod m = a w 1 b S w 1 mod m = a b S mod m. Da m > 1 i n a i, gilt auch a b = S. Dass b die einzige Lösung ist, folgt aus Lemma 2. 4 Sicherheit Bevor wir mit dem L 3 -Angriff eine konkrete Angriffsmethode kennen lernen werden, folgen einige allgemeine Sicherheitsaspekte des Knapsack-Kryptosystems. Zum Ersten ist darauf zu achten, dass der öffentliche Schlüssel kein extra simpler Vektor ist. Würden wir im obigen Beispiel m = 31 und w = 2 wählen, dann wäre a = (2, 8, 12, 30) selbst extra simpel. Dadurch könnte natürlich auch der Knapsack (a, S) einfach gelöst werden. Auch wenn der Angreifer durch irgendeine modulare Vervielfachung von a einen extra simplen Vektor erhält, kann er damit die Chiffre brechen. 5

6 Ein Angreifer könnte sich zudem einige Eigenschaften von a (Teilbarkeit, Reihenfolge) zunutze machen, um a und m zu bestimmen. Hellman und Merkle empfehlen deswegen, zusätzliche modulare Vervielfachungen zu anderen Moduln durchzuführen und die Elemente von a zu permutieren. Zu guter Letzt ist nie bewiesen worden, dass die Unterklasse von Subset-Sum, die aus den auf modularen Vielfachen von extra simplen Vektoren basierenden Probleme besteht, selbst NP-vollständig ist. Auch hier liegt also ein Risiko, da es gelingen könnte, einen polynomiellen Algorithmus zum Lösen dieser Probleme zu finden. 4.1 Der L 3 -Angriff Wie oben schon erwähnt, sind bis auf eins, nämlich das Chor-Rivest-Kryptosystem [CR88], alle Knapsack-Verschlüsselungssysteme gebrochen worden, das von Merkle und Hellman vorgestellte Originalsystem 1982 von Shamir [S82]. Auch für das Chor-Rivest-Kryptosystem existiert ein Angriff bei bestimmten Parametern [SH95]. Ein sehr allgemeiner Angriff auf Knapsack-Systeme ist der L 3 -Angriff, der 1985 von Lagarias und Odlyzko entdeckt wurde und der bei der Lösung des Subset-Sum-Problems ansetzt [LO85]. Die Idee hinter diesem Angriff ist, das Knapsackproblem (a, S), das sich aus dem öffentlichen Schlüssel a und dem Geheimtext S ergibt, als Problem der linearen Algebra darzustellen. Man definiert dazu folgende Vektoren: v 1 = ( a 1 ) v 2 = ( a 2 ).. v n 1 = ( a n 1 ) v n = ( a n ) v n+1 = ( S) Definition 3. Gegeben ist eine Menge von linear unabhängigen Vektoren {x 1,..., x k }. Die Menge aller Punkte, die sich als ganzzahlige Linearkombinationen von x 1,... x k darstellen lassen, wird Gitter genannt. Die Vektoren x 1,..., x k heißen Basis dieses Gitters. Die Vektoren v 1,..., v n+1 sind offensichtlich linear unabhängig, sie bilden zusammen also die Basis für ein Gitter. Es fällt auf, dass sich die korrekte Lösung unseres Knapsacks als Linearkombination der Vektoren v 1... v n+1 darstellen lässt, nämlich v 1 x 1 + v 2 x v n x n v n+1 = (x 1, x 2,..., x n, 0) mit x i {0, 1} für 1 i n. Der Vektor (x 1, x 2,..., x n ) ist dann die Lösung des Knapsacks. Es stellt sich jedoch die Frage, wie wir eine solche Linearkombination erhalten können. Der naive Ansatz, alle in Frage kommenden Linearkombinationen durchzuprobieren, hat natürlich genausowenig polynomielle Laufzeit wie das Lösen des Knapsacks. 6

7 Wenn wir allerdings die Vektoren v 1... v n+1 betrachten, stellen wir fest, dass sie für große n sehr lang werden, da der Vektor a ja extra simpel ist, d.h. die a i für steigendes i exponentiell größer werden. Unsere gesuchte Linearkombination ist hingegen sehr kurz. Wenn wir für unser Gitter also eine reduzierte Basis berechnen, könnte unser Lösungsvektor dabei sein. Ein effizienter Algorithmus hierfür ist der L 3 -Algorithmus. Dieser liefert für ein Gitter eine reduzierte Basis. Eine genaue Definition der Eigenschaften dieser Basis findet sich in [MOV96]; für uns ist an dieser Stelle wichtig, dass die Vektoren der so erzeugten Basis signifikant kürzer sind als die unserer Eingabebasis und dass wir tatsächlich mit einer hohen Wahrscheinlichkeit unseren Lösungsvektor darunter finden. Natürlich liegt die reduzierte Basis selbst auch wieder im Gitter, so dass der gefundene Vektor eine Linearkombination der Ausgangsvektoren ist. Folgender Algorithmus nutzt diesen Umstand für einen Angriff auf das Knapsack- System: Algorithmus 2 1: function L 3 -Attack(v, a, S) 2: w L 3 (v) 3: for all w i w do 4: if w i is like (y 1, y 2,..., y n, 0), y i {0, b}; 1 i n, b Z\{0} then 5: x 1 b w i 6: if a x = S then 7: return x 8: return NULL Der Algorithmus lässt sich zuerst vom L 3 -Algorithmus für das durch v beschriebene Gitter eine reduzierte Basis geben. Für diese Basis prüft er nun für jeden Vektor, ob er von der Form ist, dass auf den vorderen n Stellen entweder eine ganze Zahl b oder 0 steht und die letzte Stelle 0 ist. Ist dies der Fall, dann wird der gefundene Vektor mit 1 b multipliziert und dann getestet, ob er auch eine Lösung für den übergebenen Knapsack (a, S) ist. Das muss nicht immer der Fall sein, denn v n+1 könnte in der zugehörigen Linearkombination auch mit einem anderen Faktor als b vorkommen. Haben wir eine Lösung gefunden, dann sind wir an dieser Stelle fertig. Ansonsten wird mit dem nächsten Vektor der reduzierten Basis fortgefahren. Laufzeit: Der L 3 -Algorithmus hat eine Laufzeit von O(n 4 + log 2 m) [MOV96]. Da n log 2 m gilt, ist die Laufzeit in diesem Fall O(log 4 n). Der Rest des Algorithmus hat eine Laufzeit von O(log 3 m), also ergibt sich als Gesamtlaufzeit O(log 4 m). Nun bleibt noch die Frage offen, mit welcher Erfolgswahrscheinlichkeit bei diesem Angriff zu rechnen ist. 7

8 Definition 4. Die Dichte eines Vektors a ist definiert als d(a) = n max 1 i n log 2 a i. Für einen Knapsack (a, S) findet der L 3 -Angriff mit hoher Wahrscheinlichkeit eine Lösung, wenn d(a) < 0, 9408 [MOV96]. Für einen Knapsack, bei dem a aus aufeinanderfolgenden Zweierpotenzen besteht, also den dichtestmöglichen Knapsack, geht die Dichte für n gegen 1. In der Praxis sind Dichten größer als 0, 9408 also zu vernachlässigen. Für das obige Beispiel funktioniert der Angriff übrigens, obwohl die Dichte größer als 0, 9408 ist. Das kann man mit der Maple-Funktion Lattice, die eine L 3 -Reduktion durchführt, leicht überprüfen: Beispiel(Fortsetzung). Für das Beispiel aus Kapitel 3 (a = (7, 28, 12, 15); S = 50) erzeugt der Maple-Befehl lattice([[1, 0, 0, 0, 7], [0, 1, 0, 0, 28], [0, 0, 1, 0, 12], [0, 0, 0, 1, 15], [0, 0, 0, 0, 50]]); eine reduzierte Basis bestehend aus den Vektoren (0, 1, 1, 1, 1), (1, 1, 0, 1, 0), ( 1, 2, 0, 0, 1), ( 2, 0, 0, 1, 1) und (0, 1, 2, 0, 2). Der Vektor (1, 1, 0, 1, 0) ist dabei von der von uns gewünschten Form. Die Überprüfung ergibt, dass = 50 gilt. Also ist der Vektor (1, 1, 0, 1) die Lösung für den Knapsack. 5 Fazit Wir haben das NP-schwere Problem Subset-Sum benutzt, um über eine Trapdoor ein asymmetrisches Kryptosystem aufzubauen. Auch, wenn die verwendete Unterklasse von Problemen nicht erwiesenermaßen NP-schwer ist - es ist kein polynomieller Algorithmus bekannt, der diese Probleme löst. Trotzdem ist unser System nicht sicher, denn wir können das Problem mit nichttrivialer Wahrscheinlichkeit in polynomieller Laufzeit lösen: Unsere Worst-Case-Laufzeit ist nicht polynomiell, aber im Normalfall finden wir schneller eine Lösung. Wir stellen also fest, dass die Worst-Case-Zeitkomplexität der zugrundeliegenden Probleme keine Antwort auf die Frage gibt, ob ein Kryptosystem sicher ist. Entscheidend ist die Frage, ob diese Probleme mit einer gewissen Wahrscheinlichkeit oder sogar im Average Case schnell gelöst werden können. 8

9 6 Quellen [M OV 96] Menezes, van Oorschot, Vanstone Handbook of Applied Cryptography, CRC 1996; S. 118ff [CR88] B. Chor, R.L. Rivest - A knapsack-type public-key cryptosystem based on arithmetic in finite fields, IEEE Transactions on Information Theory, Vol. 34, Nr. 5, 1988; S [SH95] C.P. Schnorr, H.H. Hörner - Attacking the Chor-Rivest cryptosystem by improved lattice reduction, Advances in Cryptology - Eurocrypt 95, Springer- Verlag [M H78] Ralph C. Merkle, Martin E. Hellman - Hiding Information and Signatures in Trapdoor Knapsacks, IEEE Transactions on Information Theory, Vol. 24, Nr. 5, 1978; S [S82] Adi Shamir - A polynomial time algorithm for breaking the basic Merkle- Hellman Cryptosystem, Proceedings of the 23rd FOCS Symposium, 1982, S [LO85] J. C. Lagarias, A. M. Odlyzko - Solving Low Density Subset Sum Problems, Journal of the Association for Computing Machinery, Vol. 32, 1985; S [CLRS01] T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein - Introduction to Algorithms, second edition, MIT Press 2001; S. 1013ff 9