Shift-and-Add-Multiplikation

Transkript

1 Shift-and-Add-Multiplikation In diesem Kapitel behandeln wir die Multiplikation zweier Körperelemente im binären Erweiterungskörper F 2 m, d.h. für Polynome a(x), b(x) œ Z 2 [x] f(x) und einem irreduziblen Polynom f(x) =x m + r(x) œ Z 2 [x] vom Grad m berechnen wir a(x) f b(x) =a(x)b(x) mod f(x). Im Prinzip können wir das bereits berechnen, indem wir die beiden Polynome a(x) und b(x) ausmultiplizieren und anschließend nach dem bereits genannten Verfahren reduzieren. Einen anderer Ansatz, bei dem immer nach Zwischenschritten modulo f(x) reduziert wird, beschreibt der folgende Algorithmus, der auch Shift-and-Add genannt wird. Der Vorteil bei diesem Algorithmus im Vergleich zur erstgenannten Variante liegt darin, dass man immer Polynome als Zwischenwerte erhält die höchstens den Grad m haben. Würde man die Polynome erst vollständig ausmultiplizieren, so hätte man Polynome mit Grad 2m, was für die praktische Implementierung bedeuten würde, dass man doppelt so lange Register benötigt. Bei kleinen Körpern spielt das kaum eine Rolle, aber bei Körpern mit beispielsweise Elementen, die auf einer resourcenbeschränkten Hardware implementiert werden sollen, ist das unter Umständen vorteilhaft. Ein weiterer Vorteil des Shift-and-Add ist die hardwarefreundliche Realisierbarkeit. Es lassen sich einfache Multiplizierer auf Basis einer einfachen Schieberegisteroperation implementieren. Grundlage des ersten Shift-and-Add-Algorithmus ist folgende Überlegung. Seien a(x) und b(x) die beiden Polynome und sei f(x) das Reduktionspolynom. Multiplizieren wir a(x) mit b(x),

2 40 michael braun dann können wir a(x) voll ausschreiben a(x) =a m 1 x m a 1 x + a 0 und jeden Summanden mit b(x) multiplizieren. Eine wesentliche Eigenschaft der Modulo-Operation besteht darin, dass wir nun modulo f(x), anstatt auf das gesamte ausmultiplizierte Polynom a(x)b(x), auf einzelne Summanden anwenden können, ohne das Endergebnis zu verändern. Insgesamt können wir also schreiben: a(x)b(x) mod f(x) = a 0 b(x) B 0 + a 1 xb(x) mod f(x) B 1 =xb 0 mod f(x) + a 2 x 2 b(x) mod f(x) B 2 =xb 1 mod f(x). + a m 1 x m 1 b(x) mod f(x) B m 1 =xb m 2 mod f(x) Man erkennt sofort, dass sich daraus ein Algorithmus ableiten lässt, denn vom niedrigsten Koe zienten a 0 bis zum höchsten Koe zienten a m 1 wird von Zeile zu Zeile der Wert b(x) neu := xb(x) alt mod f(x) berechnet und mit a i multipliziert und zum Gesamtergebnis dazuaddiert. Da a i nur Null oder Eins ist, ist die Multiplikation mit a i gleichbedeutend mit einer If-Abfrage: Entweder wird b(x) neu zum Ergebnis c(x) addiert, wenn a i = 1, oderb(x) neu wird nicht dazu addiert, wenn a i = 0 ist. Wir erhalten also den folgenden Algorithmus. Algorithmus 10 (R2L-Shift-and-Add (Polynome)). Input: f(x) =x m + r(x) œ Z 2 [x], a(x), b(x) œ Z 2 [x] f(x) Output: c(x) =a(x) f b(x) 1 c(x) := 0 2 for i := 0 to m 1 do 3 if a i = 1 then c(x) := c(x)+b(x) 4 b(x) := xb(x) mod f(x) 5 return c(x)

3 public-key-algorithmen 41 Der einzige noch nicht geklärte Teil ist die Berechnung in Zeile 4. Um diese Operation algorithmisch aufzubereiten, müssen wir uns zunächst überlegen, was es bedeutet ein Polynom b(x) mit x zu multiplizieren und danach modulo f(x) zu reduzieren. Es gilt: xb(x) mod f(x) = x(b m 1 x m 1 + b m 2 x m b 1 x + b 0 ) mod f(x) = b m 1 x m + b m 2 x m b 1 x 2 + b 0 x + b d 1 f(x) mod f(x) = b m 1 x m + b m 2 x m b 1 x 2 + b 0 x + b m 1 (x m + r(x)) mod f(x) = b m 1 x m + b m 2 x m b 1 x 2 + b 0 x + b m 1 x m + b m 1 r(x) =(b m 2 x m b 1 x 2 + b 0 x + 0)+b m 1 r(x) mod f(x). Das Ergebnis xb(x) mod f(x) lässt sich in zwei Schritten berechnen: ein Linksshift von b(x) in Vektordarstellung und anschließende Addition von f(x) (bzw. von r(x), wenn man das vorderste Bit b m 1 in xb(x) nicht berücksichtigt), falls das vorderste Bit von b(x) gleich Eins ist. Insgesamt ergibt sich nun folgende Verfeinerung des Multiplikationsalgorithmus Shift-and-Add, der seinen Namen von der den beiden so eben erklärten Schritten: (1) Schieben von b(x), und (2) Addition von g(x). In diesem Algorithmus verwenden wir die Vektordarstellungen der Polynome. Bezeichnet im folgenden u(x) = q d i=0 u i x i ein Polynom, so wird mit dem Vektor u = u d...u 1 u 0 das Polynom u(x) dargestellt. Des weiteren bezeichnet s ü u für Vektoren s, u gleicher Länge das komponentenweise xor und u<<1 den um eine Position nach Links verschobene Vektor u, d.h. es wird an u rechts der Wert 0 angehängt: u<<1 := u d...u 1 u 0 0. Algorithmus 11 (R2L-Shift-and-Add (Vektoren)). Input: a, b, r œ Z m 2 mit f(x) =xm + r(x) Output: c œ Z m 2 mit c(x) =a(x) f b(x) 1 c := 0 2 for i := 0 to m 1 do 3 if a i = 1 then c := c ü a 4 b := b<<1 5 if b m = 1 then b := b ü f 6 return c = c m 1...c 1 c 0

4 42 michael braun Der Aufwand zur Durchführung beträgt O (m2 ) Bitoperationen: Für jeden der m Schleifendurchläufe werden maximal zwei binäre Vektoren der Länge m addiert. Bei einer Softwareimplementierung auf einer Plattform mit q einem W -Bit-Prozessor, kann man Polynome a(x) = m 1 i=0 ai xi aus dem Körper F2m bzw. die entsprechenden binären Vektoren a = am 1... a1 a0 in einem Array A bestehend aus t = Ám/W Ë Wörtern speichern: A[t 1]... A[1]A[0] = am 1... a1 a0. tw m Bei xor- und Schiebeoperationen können bei geschickter Implementierung jeweils W Bit parallel verarbeitet werden. Der Aufwand der einzelnen Operationen kann damit um einen Faktor W reduziert werden. Bei einer Hardwareimplementierung kann durch die Verwendung von Schieberegistern der gewünschten Länge m der zeitliche Aufwand auf O (m) reduziert werden. Schiebe- und xoroperationen können in O (1) durchgeführt werden. Beispielsweise zeigt Abbildung 11 das Schaltwerk eines R2L-Shift-and-AddMultiplizierer in F25 mit f (x) = x5 + x b4 b3 b2 b1 b0 & & & & & c4 c3 c2 c1 c0 0 a 0, a1, a2,... Eine weitere Shift-and-Add-Variante erhalten wir aus a(x)b(x) durch sukzessives Ausklammern des Faktors x: a(x)b(x) = (... (am 1 b(x)x + am 2 b(x))x a1 b(x))x + a0 b(x). Diese Abfolge kann man realisieren (beginnend von m 1 bis 0), indem man das Ergebnispolynom c(x) zuerst mit x multipliziert und anschließend b(z ) dazuaddiert wird, falls ai = 1 ist. Analog wie bei dem R2L-Algorithmus wird das Ergebnis nach jeder Schiebeoperation modulo f (z ) gerechnet, indem das Polynom r (x) dazuaddiert wird, falls das höchstwertige Bit von c(x) Eins war. Abbildung 11: Multiplizierer für f (x) = x5 + x2 + 1

5 public-key-algorithmen 43 Der entsprechende Algorithmus in Vektorschreibweise kann wie folgt formuliert werden. Aufgrund der Abarbeitung des Polynoms a(x) =a m 1 x m a 1 x + a 0 vom höchstwertigen zum niederwertigsten Bit, also von links nach rechts sprechen wir von der L2R-Shift-and-Add-Variante. Algorithmus 12 (L2R-Shift-and-Add (Vektoren)). Input: a, b, r œ Z m 2 mit f(x) =xm + r(x) Output: c œ Z m 2 mit c(x) =a(x) f b(x) 1 c := 0 2 for i := m 1 downto 0 do 3 c := c<<1 4 if c m = 1 then c := c ü f 5 if a i = 1 then c := c ü b 6 return c = c m 1...c 1 c 0 Die Hardwareimplementierung von L2R-Shift-and-Add benötigt nur ein veränderbares Register c im Gegensatz zu R2L-Shiftand-Add, bei der zwei modifizierbare Register b und c verwendet werden.

6

7 Polynommultiplikation nach Karatsuba-O man Durch volles Ausmultiplizieren von Polynomen a(x), b(x) œ Z p [x] mit Grad kleiner als m erhält man eine Komplexität O(m 2 ). Ziel dieses Kapitels ist die Beschreibung des Algorithmus nach Karatuba und O man, welcher asymptotisch einen Aufwand von O(m log2(3) ) O(m 1,59 ) hat. Dazu stellen wir Polynome a(x) = q m 1 i=0 a ix i durch zwei Polynome A 0, A 1 œ Z p [x] mit Grad kleiner als k := Ám/2Ë dar: a(z) =A 1 x k + A 0. Die Multiplikation zweier Polynome a(x), b(x) dieser Form ergibt: a(x)b(x) =(A 1 x k + A 0 )(B 1 x k + B 0 ) Nach Ausmultiplizieren gilt nun bzw. = A 1 B 1 x 2k +(A 1 B 0 + A 0 B 1 )x k + A 0 B 0. (A 0 +A 1 )(B 0 +B 1 )=A 0 B 0 + A 1 B 0 + A 0 B 1 + A 1 B 1 A 1 B 0 + A 0 B 1 =(A 0 +A 1 )(B 0 +B 1 ) A 0 B 0 A 1 B 1 Einsetzen in obige Gleichung ergibt a(x)b(x) =A 1 B 1 x 2k +[(A 0 +A 1 )(B 0 +B 1 ) A 0 B 0 A 1 B 1 ]x k + A 0 B 0 Anstelle von ursprünglichen vier Multiplikationen A 0 B 0, A 1 B 0, A 0 B 1 und A 1 B 1 halber Länge k m/2 müssen wir in dieser Gleichung drei Multiplikationen A 0 A 1, A 1 B 1, (A 0 +A 1 )(B 0 +B 1 )

8 46 michael braun halber Länge k durchführen, um a(x)b(x) zu berechnen. (Natürlich wurden bei dieser Betrachtung Additionen von Polynomen der Länge k zunächst vernachlässigt.) Die Abbildung 12 visualisiert dieses Verhalten. Zunächst erkennt man ganz links ein schwarzes Quadrat. Die Kantenlänge soll den Wert m darstellen. Ein ganz ausgefülltes Quadrat entspricht somit dem Aufwand O(m 2 ). Das mittlere Bild zeigt nun noch drei Multiplikationen der halben Kantenlänge k m/2. Iteriert man diesen Ansatz, dass man eine Multiplikation durch drei Multiplikationen von Polynomen halber Länge schreiben kann, so ergibt sich das Bild ganz rechts. Der schwarz dargestellte Fläche entspricht dem Aufwand bei iterierter Anwendung der Karatsuba-O man-umformung. Insgesamt ergibt sich eine Komplexität von O(m log 2(3) ) O(m 1,59 ). Zeigen kann man dies mit dem Mastertheorem. Geometrisch handelt es sich bei der Figur um ein Fraktal mit der Dimension log 2 (3) =1, 59. Abbildung 12: Asymptotisches Verhalten bei Karatsuba-O man klassisch: Karatsuba Karatsuba Asymptotisch ist Karatsuba-O man besser als die zuvor vorgestellten Methoden, aber der Mehraufwand durch Aufsplitten und den zusätzlichen Operationen wie Addition lohnt sich erst ab einem Grad von m 300. Neben Karatsuba-O man gibt weitere asymptotisch schnellere Multiplikationsmethoden als O(m 2 ): Diskrete Fouriertransformation: O(m log 2 (m)) Schönhage-Strassen: O(m log 2 (m) log 2 (log 2 (m))

9 Binäre Polynomquadierung Um ein binäres Polynom a(x) =a m 1 x m a 1 x + a 0 œ Z 2 [x] mit sich selbst zu multiplizieren, können wir natürlich die bisher beschriebenen Algorithmen verwenden. Nutzt man jedoch die Arithmetik der Koe zienten in Z 2 aus, so kann die Qudrierung e zienter gelöst werden. Es gilt a(x) 2 = a(x)a(x) =a m 1 x 2m a 1 x 2 + a 0. Da alle gemischten Koe zienten a i a j für i = j genau zweimal in der Summe auftreten, fallen diese modulo 2 weg und es bleiben ausschließlich die genannten Koe zienten bei der Quadrierung ürbig. In Vektorschreibweise erhalten wir a 2 = 0a m 1 0a m a 2 0a 1 0a 0, d.h. durch Aufspreizen des Vektors a und Einfügen von Nullen ergibt sich a 2. Der Aufwand zur Quadrierung beträgt somit O(m). Bei Softwareimplementierungen auf W -Bit-Plattformen kann dieses Aufspreizen beschleunigt werden, indem man z.b. alle 2 W /4 möglichen Bitfenster der Länge W /4 aufspreizt, Nullen einfügt und die Ergebnisse der Länge W /2 in einer Tabelle abspeichert. Bei dem Aufspreizen eines Arrays A für das Polynom a(x) werden dann sukzessive alle Fenster der Größe W /4 von A abgearbeitet und mittels Table-Lookup zu einem Array B zusammengesetzt, welches dann das Polynom b(x) =a(x) 2 darstellt. Bei Hardwareimplementierung kann man ähnlich den Shiftand-Add-Verfahren ein Schaltwerk angeben, welches durch direkte Verdrahtung die Quadrierung a(x) 2 und anschließende Reduktion modulo f(x) angibt.

10 48 michael braun Beispiel 10. Als Beispiel betrachten wir das Polynom den Körper F27. Ein unzerlegbares binäres Polynom vom Grad 7 ist f (x) = x7 + x + 1. Wir nehmen ganz allgemein a(x) = a6 x a1 x + a0. Durch Quadrieren und Reduktion modulo f (x) erhalten wir a(x)2 mod f (x) = a6 x12 + a5 x10 + a4 x8 + a3 x6 + a2 x4 + a1 x2 + a0 mod x7 + x + 1 = (a6 + a3 )x6 + a6 x5 + (a2 + a5 )x4 + a5 x3 + (a1 + a4 )x2 + a4 x + a0. Eine direkte Verdrahtung dieser modularen Quadrierung ergibt beispielsweise das Schaltwerk in Abbildung 13. a6 a5 a4 a3 a2 a1 a0 c6 c5 c4 c3 c2 c1 c0 Abbildung 13: Hardwarequadrierer in F27

11 Binäre Polynommultiplikation Im folgenden werden wir zwei binäre Polynome ausmultiplizieren. Dazu setzen wir, wie bereits im Shift-and-Add-Kapitel beschrieben, voraus dass wir eine W -Bit Plattform haben und die binären Polynome a(x) = q m 1 i=0 a ix i entsprechend in einem Array der Länge t = ÁW /më ablegen: A[t 1]...A[1]A[0] =0...0a m 1...a 1 a 0. Desweitern bezeichnet für ein W -Bit Wort U = U W 1...U 1 U 0 das Bit U i mit bit(u, i). Für Polynome a(x) = q m 1 i=0 a ix i und b(x) = q m 1 i=0 b ix i gilt: a(x)b(x) =a 0 x 0 b(x)+a 1 x 1 b(x)+...+ a m 1 x m 1 b(x). Entsprechend ergibt sich der folgende Algorithmus: Wir durchlaufen alle Koe zienten von a(x) und addieren im Falle, dass das Bit a i gleich Eins ist, das mit x i multiplizierte Polynom b(x) zum Akkumulator. In Vektor- bzw. Arrayschreibweise erhalten wir: 1 C := 0 2 for i := 0 to m 1 do 3 if a i = 1 then 4 C := C ü (B <<i) 5 return C Bitweises Abarbeiten des Polynoms a(x) als Array A ergibt eine geschachtelte Schleife:

12 50 michael braun 1 C := 0 2 for k := 0 to W 1 do 3 for j := 0 to t 1 do 4 if bit(a[j], k) =1 then 5 C := C ü (B <<(jw + k)) 6 return C Ist nun C = C[n 1]...C[1]C[0] ein binäres Array, so bezeichnen wir mit C{j} := C[n 1]...C[j + 1]C[j] das abgeschnittene Array. Mit Hilfe dieser Operation können wir die Operation durch den Ausdruck C := C ü (B <<(jw + k)) C{j} := C{j} ü(b <<k) beschreiben. Sukzessives Schieben des Registers B ergibt folgenden Algorithmus: Algorithmus 13 (R2L-Kamm-Multiplikation (Array)). Input: Arrays A, B mit binären Polynomen a(x), b(x) Output: Array C mit binärem Polynom c(x) =a(x)b(x) 1 C := 0 2 for k := 0 to W 1 do 3 for j := 0 to t 1 do 4 if bit(a[j], k) =1 then 5 C{j} := C{j} üb 6 if k = W 1 then B := B<<1 7 return C Anstatt beim niederwertigsten Bit zu beginnen, kann analog zum Shift-and-Add beim höchstwertigen Bit beginnen (Die Schleife für j kann trotzdem von 0 nach t 1 gelaufen werden, da die Operationen unabhängig von der Reihenfolge sind). In diesem Fall muss das Register C geschoben werden. Da C bis auf Länge 2t anwächst, benötigt die resultierende L2R-Kamm-Multiplikation mehr Schiebeoperationen als die R2L-Kamm-Multiplikation.

13 public-key-algorithmen 51 Algorithmus 14 (L2R-Kamm-Multiplikation (Array)). Input: Arrays A, B mit binären Polynomen a(x), b(x) Output: Array C mit binärem Polynom c(x) =a(x)b(x) 1 C := 0 2 for k := W 1 to 0 do 3 for j := 0 to t 1 do 4 if bit(a[j], k) =1 then 5 C{j} := C{j} üb 6 if k = 0 then C := C<<1 7 return C Anstatt die W Bit mit dem Laufindex k nacheinander abzuarbeiten, kann man diese auch in kleinere Fenster der Länge w, welche ein Teiler von Wortbreite W ist, aufteilen und Zwischenergebnisse für kleine Polynome vorberechnen. Algorithmus 15 (Table-Lookup-L2R-Kamm (Array)). Input: Arrays A, B mit binären Polynomen a(x), b(x) Output: Array C mit binärem Polynom c(x) =a(x)b(x) 1 berechne B u = u(x)b(x) für u(x) vom Grad <w 2 C := 0 3 for k := (W /w) 1 to 0 do 4 for j := 0 to t 1 do 5 u := [bit(a[j], wk +(w 1)),...,bit(A[j], wk)] 6 C{j} := C{j}üB u 7 if k = 0 then C := C<<w 8 return C Die Vorberechnung der Werte u(x)b(x) für Polynome u(x) vom Grad w kann beispielsweise mit der R2L-Methode durchgeführt werden.

14

15 Modulare binäre Polynomreduktion Durch die Multiplikation von zwei Polynomen jeweils vom Grad höchstens m 1 entsteht ein Polynom c(x) vom Grad höchstens 2m 2. Dieses Polynom muss nun modulo f(z) =x m + r(x) reduziert werden. Um das i-te Bit von c(x) für 2m 2 Ø i Ø m zu reduzieren wir allgemein folgender Schritt durchgeführt: c(x) mod f(x) = c i x i + c i 1 x n c 0 mod f(x) = c i x i + c i 1 x n c 0 + c i x i m f(x) mod f(x) = c i x i + c i 1 x n c 0 + c i x i m (x m + r(x)) mod f(x) =(c i 1 x n c 0 )+c i x i m r(x) mod f(x). In Array-Darstellung ergibt sich folgender Algorithmus: 1 for i := 2m 2 downto m do 2 if c i = 1 then 3 C := C ü (R <<(i m)) 4 return C (auf m Bit maskiert) Berechnen wir aus i den entsprechenden Index j, der angibt um viele ganze W -Bit Wörter der Shift durchgeführt wird und den Index k, der angibt, um viele Reststellen innerhalb eines W -Bit Wortes geschoben wird, so erhalten wir folgende Variante: 1 for i := 2m 2 downto m do 2 if c i = 1 then 3 j := (i m)/w ; k := (i m) jw 4 C := C ü (R <<(jw + k)) 5 return C (auf m Bit maskiert)

16 54 michael braun Substiutieren wir die Operation durch den Ausdruck C := C ü (R <<(jw + k)) C{j} := C{j} ü(r <<k) wie im letzten Kapitel, so erhalten wir eine weitere Variante 1 for i := 2m 2 downto m do 2 if c i = 1 then 3 j := (i m)/w ; k := (i m) jw 4 C{j} := C{j} ü(r <<k) 5 return C (auf m Bit maskiert) Da R immer nur jeweils um k Stellen zwischen 0 und W 1 geschoben werden muss, berechnen wir vorab die Werte U k := R<<kfür alle möglichen Werte 0 Æ k<w. Dies erspart uns die Schiebeoperationen bei der eigentlichen Reduktion: Algorithmus 16 (Reduktion). Input: Array C mit Polynom c(x) vom Grad höchstens 2m 2, Array R wobei f(x) =x m + r(x) unzerlegbar ist Output: Array C mit c(x) mod f(x) A Precomputation: for all k := 0 to W 1 do U k := R<<k 1 for i := 2m 2 downto m do 2 if c i = 1 then 3 j := (i m)/w ; k := (i m) jw 4 C{j} := C{j}üU k 5 return C (auf m Bit maskiert) Für Reduktionspolynome, bei denen nur wenige Bit gesetzt sind (3 oder 5), und die Bit eng bei einander liegen, kann man e zienter reduzieren als mit dem allgemeinen Algorithmus. Wir betrachten im folgenden eine optimierte Reduktion für das binäre Polynom f(x) =x x 7 + x 6 + x =r(x) In hexadezimaler Notation auf einer 32-Bit-Plattform wird dies als Array F [5]...F[1]F [0] =(0x8, 0x0, 0x0, 0x0, 0x0, 0xC9)

17 public-key-algorithmen 55 dargestellt. Um nun in einem Polynom c(x) = q 324 i=0 c ix i ein Bit c i für i Ø 163 zu reduzieren, so muss man nach den vorangegangenen Überlegungen c i x i 163 r(x) zu c(x) addieren. Folglich muss in c(x) an den Stellen i = i 156 i = i 157 i = i 160 i = i 163 der Wert c i addiert werden. Demnach ergibt sich folgender erster Reduktionsalgorithmus 1 for i := 324 downto 163 do 2 c i 156 := c i 156 ü c i 3 c i 157 := c i 157 ü c i 4 c i 160 := c i 160 ü c i 5 c i 163 := c i 163 ü c i 6 return c(x) Wir untersuchen nun, was es bedeutet im Polynom c(x) das Bit c i zu reduzieren, wenn c(x) in einem Array C[10]...C[1]C[0] abgelegt ist. Dazu sehen wir uns für i die beiden Grenzen in dem Datenwort C[j] an: Für i = 32j + 31 wird an den Stellen 32(j 4)+3, 32(j 4)+2, 32(j 5)+31, 32(j 5)+28 der Wert c i addiert. Für i = 32j wird an den Stellen 32(j 5)+4, 32(j 5)+3, 32(j 5), 32(j 6)+29 der Wert c i addiert. Folglich wird das Datenwort C[j] auf die Wörter C[j 4], C[j 5] und C[j 6] addiert. Entsprechend lässt sich eine Variante der speziellen Reduktion modulo f(x) für Arrays formulieren:

18 56 michael braun 1 for j := 10 downto 6 do 2 T := C[j] 3 C[j 6] := C[j 6] ü (T <<29) 4 C[j 5] := C[j 5] ü (T <<4) ü (T <<3) ü T ü (T >>3) 5 C[j 4] := C[j 4] ü (T >>28) ü (T >>29) 6 T := (C[5] >> 3) << 3 /* oder T := C[5]&0xF F F F F F F 8 */ 7 C[0] := C[0] ü (T <<4) ü (T <<3) ü T ü (T >>3) 8 C[1] := C[1] ü (T >>28) ü (T >>29) 9 C[5] := C[5]&0x7 10 return C Es können noch eine Schiebeoperation eingespart werden, wenn man den Linksshift in Zeile 6 direkt bei den Operationen in den Zeilen 7 und 8 verarbeitet. Algorithmus 17 (spezielle Reduktion). Input: Array C mit Polynom c(x) vom Grad höchstens 324 Output: Array C mit c(x) mod x x 7 + x 6 + x for j := 10 downto 6 do 2 T := C[j] 3 C[j 6] := C[j 6] ü (T <<29) 4 C[j 5] := C[j 5] ü (T <<4) ü (T <<3) ü T ü (T >>3) 5 C[j 4] := C[j 4] ü (T >>28) ü (T >>29) 6 T := C[5] >> 3 7 C[0] := C[0] ü (T <<7) ü (T <<6) ü (T <<3) ü T 8 C[1] := C[1] ü (T >>25) ü (T >>26) 9 C[5] := C[5]&0x7 10 return C

19 Euklidischer Algorithmus für binäre Polynome Algebraisch betrachtet bildet (Z, +, ) einen euklidischen Ring. Allgemein heißt ein Integritätsring (R, +, ) euklidisch, wenn es eine multiplikative Abbildung N : R\{0} æ N gibt (die so genannte Normfunktion), so dass für alle Ringelemente a, b œ R, b = 0, weitere Ringelemente s, r œ R existieren mit a = sb + r wobei r = 0 oder N(r) <N(b). Eine Abbildung N : R\{0} æn heißt genau dann multiplikativ, wennn(a b) =N(a) N(b) gilt für alle a, b œ R. Für den euklidischen Ring der ganzen Zahlen Z ist die Normfunktion entsprechend der Betrag N(a) = a. Einen weiteren euklidischen Ring, den wir nun betrachten werden, bildet der Polynomring Z 2 [x]. Für Polynome a œ Z 2 [x] ist die Normfunktion durch den Grad N(a) =deg(a) des Polynoms definiert. Im folgenden schreiben wir a, b, c,... als verkürzte Form für Polynome a(x), b(x), c(x),... Theorem 7. Für Polynome a, b œ Z 2 [x], b = 0, existieren eindeutige Polynome s, r œ Z 2 [x] mit a = sb + r, wobei r = 0 oder deg(r) < deg(b) gilt. Definition 6. Ein Polynom a œ Z 2 [x] teilt genau dann ein Polynom b œ Z 2 [x], wenneseinc œ Z 2 [x] gibt mit ac = b. Das Polynom a heißt dann auch ein Teiler von b. Definition 7. Eine Polynom t œ Z 2 [x] heißt genau dann der größter gemeinsamer Teiler von a, b œ Z 2 [x], wennt ein Teiler von a und b ist und falls jeder Teiler s œ Z 2 [x] von a und b das Polynom t teilt. Der größte gemeinsamen Teiler von a und b wird mit gcd(a, b) abgekürzt.

20 58 michael braun Analog zu den Regeln für die Menge der größten gemeinsamen Teiler ganzer Zahlen erhalten wir die gleichen Ergebnisse für Polynome, aus denen man leicht den euklidischen Algorithmus in der rekursiven und iterativen Version ableiten kann. Lemma 4. Für den größten gemeinsamen Teiler von a, b, s œ Z 2 [x] gilt: 1. gcd(a, a) =a 2. gcd(a,0)=a 3. gcd(a,1)=1 4. gcd(as, bs) =s gcd(a, b) 5. gcd(b, a + sb) =gcd(a, b) 6. gcd(b, a mod b) =gcd(a, b) Die entsprechende Variante des Lemmas von Bézout für Polynome lässt sich wie folgt formulieren. Lemma 5 (Bézout für Polynome). Für Polynome a, b œ Z 2 [x] existieren Polynome g, h œ Z 2 [x] mit ag + bh = gcd(a, b). Da sich die Versionen des euklidischen und steinschen Algorithmus für Polynome formulieren lassen, geben wir hier ausschließlich den erweiterten steinschen Algorithmus an. Grundlage ist folgendes Lemma. Lemma 6. Für die Menge der größten gemeinsamen Teiler von a, b œ Z 2 [x] gilt: 1. gcd(a, b) =x gcd(a/x, b/x), fallsa und b durch x teilbar sind. 2. gcd(a, b) =gcd(a/x, b), fallsa durch x teilbar und b nicht durch x teilbar ist. Bei dem erweiterten steinschen Algorithmus gehen wir von den beiden invarianten Gleichungen ag 1 + bh 1 = v ag 2 + bg 2 = u

21 public-key-algorithmen 59 mit deg(v) Ø deg(u) aus, die zu Beginn des Algorithmus mit v := a, u := b sowie g 1 := 1, h 1 := 0, g 2 := 0 und h 2 := 1 belegt werden, falls deg(a) Ø deg(b). Ansonsten werden a und b vertauscht. Wir können auch davon ausgehen, dass nicht a und b beide durch x teilbar sind, ansonsten, kann man aus beiden Polynomen wiederholt x ausklammern, bis dieser Zustand erreicht wird. Wir nehmen nun ohne Einschränkung der Allgemeinheit an, dass v durch x teilbar ist. Aufgrund von Lemma 6 muss die Gleichung ag 1 + bh 1 = v derart angepasst werden, dass auf der rechten Seite v/x steht. Je nach Teilbarkeit von g 1 und h 1 durch x entstehen die folgenden Fälle: 1. Falls h 1 und g 1 durch x teilbar sind, so kann die Gleichung wie folgt angepasst werden: a(g 1 /x)+b(h 1 /x) =v/x. 2. Falls h 1 durch x teilbar und g 1 nicht durch x teilbar ist, dann ist bh 1 durch x teilbar. Da v durch x teilbar ist, muss auch ag 1 durch x teilbar sein und somit auch a. Danichta und b gleichzeitig durch x teilbar sind, ist b nicht durch x teilbar. Folglich sind g 1 + b und h 1 + a durch x teilbar. Wir modifizieren nun die Ausgangsgleichung und erhalten ag 1 + bh 1 + ab + ab = v bzw. a(g 1 + b)+b(h 1 + a) =v. Da nun g 1 + b sowie h 1 + a durch x teilbar sind, können wir diese Gleichung nun durch x dividieren: a(g 1 + b)/x + b(h 1 + a)/x = v/x. 3. Falls h 1 nicht durch x teilbar und g 1 durch x teilbar ist, kann die Gleichung analog dem zweiten Fall angepasst werden: a(g 1 + b)/x + b(h 1 + a)/x = v/x.

22 60 michael braun 4. Falls h 1 nicht durch x teilbar und g 1 durch x teilbar ist, dann ist ag 1 durch x teilbar. Da v durch x teilbar ist, muss auch bh 1 durch x teilbar sein. Folglich ist b durch x teilbar und somit a nicht durch x teilbar, da nicht a und b gleichzeitig durch x teilbar sind. Demnach sind g 1 + b und h 1 + a durch x teilbar und wir erhalten erneut die Umformung: a(g 1 + b)/x + b(h 1 + a)/x = v/x. Insgesamt erhalten wir folgenden Algorithmus: Algorithmus 18. Erweiterter steinscher Algorithmus. Input: a, b œ Z 2 [x] mit deg(a) Ø deg(b) Output: (t, g, h) mit ag + bh = gcd(a, b) 1 a Õ := a, b Õ := b, e := 1 2 while a Õ and b Õ are divisible by x do a Õ := a Õ /x, b Õ := b Õ /x, e := xe 3 g 1 := 1, h 1 := 0, v := a Õ, g 2 := 0, h 2 := 1, u := b Õ 4 while u = 0 do 5 while v is divisible by x do 6 v := v/x 7 if g 1 and h 1 are divisible by x then g 1 := g 1 /x, h 1 := h 1 /x 8 else g 1 :=(g 1 + b Õ )/x, h 1 :=(h 1 + a Õ )/x 9 while u is divisible by x do 10 u := u/x 11 if g 2 and h 2 are divisible by x then g 2 := g 2 /x, h 2 := h 2 /x 12 else g 2 :=(g 2 + b Õ )/x, h 2 :=(h 2 + a Õ )/x 13 if deg(v) Ø deg(u) then v := v + u, g 1 := g 1 + g 2, h 1 := h 1 + h 2 14 else u := u + v, g 2 := g 2 + g 1, h 2 := h 2 + h 1 15 return (ev, eg 1, eh 1 ) Dieser Algorithmus kann nur zur Inversion im endlichen Körper F 2 m verwendet werden. Für ein Polynom b(x) = q m 1 i=0 b ix i œ Z 2 [x] und ein unzerlegbares Polynom f(x) =x m + r(x) œ Z 2 [x] soll also b 1 mod f(x) berechnet werden. Setzen wir a := f im Euklidischen Algorithmus, so erhalten wir Faktoren g, h œ Z 2 [x] mit fg + bh = gcd(f, b) =1.

23 public-key-algorithmen 61 Betrachten wir die Gleichung modulo f(x), gilt bh mod f = 1, d.h. h = b 1 mod f. Wir können nun den Algorithmus 19 entsprechend vereinfachen, wenn wir voraussetzen, dass a := f ein unzerlegbares Polynom ist und wir nur an den Koe zienten h interessiert sind. Zeile 1 und 2 fallen weg, f nicht durch x teilbar ist. Entsprechend tritt in obiger Fallunterscheidung der zweite Fall auch nicht auf. Dies vereinfacht die Fallunterscheidung im Algorithmusablauf, da die Modifikation f(g 1 /x)+b(h 1 /x) =v/x nur dann auftritt, wenn h 1 durch x teilbar ist und die Modifikation f(g 1 + b)/x + b(h 1 + f)/x = v/x, wennh 1 nicht durch x teilbar ist. Die Abbruchbedingung kann auch leicht verändert werden, da wir den größten gemeinsamen Teiler bereits kennen, gcd(f, b) =1. Wir müssen also nicht bis u = 0 gehen, sondern können abbrechen, wenn v = 1 oder u = 1 ist. Im ersten Fall muss h 1 zurückgeben werden, im zweiten Fall h 2. Algorithmus 19. Inversion. Input: f, b œ Z 2 [x] mit f(x) unzerlegbar und deg(b) < deg(f) Output: b 1 mod f 1 h 1 := 0, v := f, h 2 := 1, u := b 2 while u = 1 and v = 1 do 3 while v is divisible by x do 4 v := v/x 5 if h 1 is divisible by x then h 1 := h 1 /x 6 else h 1 :=(h 1 + f)/x 7 while u is divisible by x do 8 u := u/x 9 if h 2 is divisible by x then h 2 := h 2 /x 10 else h 2 :=(h 2 + a Õ )/x 11 if deg(v) Ø deg(u) then v := v + u, h 1 := h 1 + h 2 12 else u := u + v, h 2 := h 2 + h 1 13 if v = 1 return h 1 else return h 2