IT-Security. Teil 8b: Rechnen mit beliebiger Genauigkeit Algorithmen

Transkript

1 IT-Security Teil 8b: Rechnen mit beliebiger Genauigkeit Algorithmen

2 Überblick Potenzieren Quadrieren Euklid'scher Algorithmus In den meisten Fällen wird nur mit positiven Werten gerechnet. Bei den Erweiterten Versionen des Euklid schen Algorithmus nicht. 2

3 Potenzieren I Das Potenzieren wird auf mehrfaches Multiplizieren zurückgeführt. a b c (mod m) Beispiel: 3 4? (mod 5) 3*3*3*3 1 (mod 5) Dies aber so zu implementieren ist recht langsam, es gibt einen schnelleren Algorithmus. 3

4 Potenzieren II schneller Algorithmus a n+m = a n *a m 1)Exponent wird als Binärzahl, also als Polynom mit 2er-Potenzen dargestellt. 2)Für jede 1 der Binärzahl wird ein Summand als 2er-Potenz berechnet. 3)Dann werden alle Summanden im Exponenten addiert. 4)Aus der Addition der Exponenten wird eine Multiplikation. Beispiel: a 23 = a 10111B = a = a * a 2 * a 4 * a 16 Die Folge a,a 2,a 4,a 16 lässt sich durch Quadrieren erstellen. Statt 22 Multiplikationen: 7 Multiplikationen 4

5 Potenzieren III schneller Algorithmus Aufwand n-1 Quadrierungen, wobei n die Nummer der höchste Stelle des Exponenten in Binärdarstellung mit 1 ist Für jede 1 im Binärwert eine weitere Multiplikation - 1. Typische Zahl: = B 16 Quadrierungen (17. Stelle mit 1 beginnend gezählt) 2 Einsen, d.h. eine weitere Multiplikation, also 17, statt Multiplikationen Siehe dazu: 5

6 Potenzieren IV schneller Algorithmus für a n func BigInt pow(bigint a,n) { BigInt c:= new(n*a.spart+n,1) BigInt t:= new(a.spart,a) while n>0 { if n mod 2 == 1 { c:= c*t; t:= t**2; n:= n div 2; return c func BigInt pow(bigint a,n) { BigInt c:= new(n*a.spart+n,1) BigInt t:= new(a.spart,a) while n>0 { n,bit:= shiftright(n); if bit { c:= mul(c,t); t:= square(t); return c Links die eher mathematische Version, rechts die mit Bibliotheksfunktionen shiftright() verschiebt den Parameter um 1 Bit nach rechts und liefert dazu das weggeschobene Bit. Um das Kopieren der Langzahlen zu vermeiden, können Prozeduren mit Output-Parameter benutzt werden. 6

7 Potenzieren V Division durch 2 func BigInt Bit shiftright(bigint a) { Cell lowest:= a[0]&1; BigInt c:= new(a.spart); for i:= 0 to a.spart-2 { low:= a[i+1]&1; c[i]:= ((c[i]>>1)&~highbit) (low<<highshift); c[a.spart-1]:= (c[a.spart-1]>>1); return reduce(c),lowest; Die Schiebeoperation nach rechts (>>) verlängert das Vorzeichen, so dass negative Zahlen weiterhin auch negativ bleiben. Um das Kopieren der Langzahlen zu vermeiden, können Prozeduren mit Output-Parameter benutzt werden. highbit und highshift sind global definierte Konstanten (siehe 1. Teil). 7

8 Potenzieren mit Modulo func BigInt powmod(bigint a,n,m) { BigInt res:= 1 BigInt t:= new(a.spart,a) while n>0 { if n mod 2 == 1 { res:= (res*t) mod m; t:= (t*t) mod m; // Quadrieren n:= n div 2 return res a n c (mod m) div ist ein Schieben nach rechts um 1 Bit. mod 2 ist das Prüfen des untersten Bits. Diese Version beruht eher auf mathematische Definitionen, die Version mit Bibliotheksroutinen wird analog zum vorherigen Beispiel programmiert. 8

9 Quadrieren I z= a 3 *B 3 +a 2 *B 2 +a 1 *B 1 +a 0 *B 0 (a+b)(a+b) = a 2 +2ab+b 2 (a+b+c)(a+b+c) = a 2 +ab+ac+ab+b 2 +bc+ac+bc+c 2 = a 2 +b 2 +c 2 +2ab+2ac+2bc (a+b+c+d)(a+b+c+d) = a 2 +b 2 +c 2 +d 2 +ab+ac+ad+ab+bc+bd+ac+bc+cd+ad+bd+cd Jede Binärzahl ist ein Polynom. Das Quadrieren kann daher als Verallgemeinerung der Binomischen Formeln angesehen werden, wenn die Summen als die Polynome aufgefasst werden. Die Potenzen der Basis entsprechen den Positionen im Array der Langzahl, also z.b. a+b = a 1 *B 1 +a 0 *B 0. 9

10 Quadrieren II func BigInt square(bigint a) { Cell2 tmp; BigInt c:= new(2*a.spart+1,0); for i:= 0 to a.spart-1 { for j:= i+1 to a.spart-1 { tmp:= a[i]*a[j]; addcell2(c,i+j,tmp); addcell2(c,i+j,tmp);// 2 Mal tmp:= a[i]*a[i]; addcell2(c,2*i,tmp); // Addition der Quadrate return c; Die Routine addcell2() wurde im 1. Teil definiert. Es werden ca % Multiplikationen gespart. 10

11 Potenzieren mit Modulo Primzahl func BigInt powmodprim(bigint a,n,p) { if n < p-1 { return powmod(bigint a,n,p); if a < p { n:= n mod (p-1); return powmod(bigint a,n,p); if ggt(a,p)=1 { n:= n mod (p-1); return powmod(bigint a,n,p); a n c (mod p) Keine Optimierung möglich Satz kann immer angewendet werden a darf kein k*p mit k=1,.. sein. Optimieren nach dem kleinen Satz von Fermat durch Verkleinern der Potenz 11

12 Binärer Euklid scher Algorithmus I Dieses Verfahren wird auch Steinscher Algorithmus genannt. Er basiert auf folgenden Zusammenhängen: ggt(a,b) = 2*ggT(a/2,b/2), falls a und b gerade ggt(a,b) = ggt(a/2,b), falls a gerade und b ungerade ggt(a,b) = ggt((a-b)/2,b), falls a und b ungerade Der wichtigste Punkt ist, dass Multiplikationen und Divisionen mit 2 mit Verschieben sehr schnell realisiert werden können. Dazu gibt es folgende Routinen: BigInt Bit shiftright(bigint a) BigInt shiftleft(bigint a, nat cnt) 12

13 Binärer Euklid'scher Algorithmus II func BigInt gcdbin(bigint a>=0,b>=0) { for k:= 0; even(a) and even(b);k++ { a:= a/2; b:= b/2; while a!=0 { while even(a) { a:= a/2; ggt(a,b) = ggt(a/2,b) while even(b) { b:= b/2; ggt(a,b) = ggt(a,b/2) if a<b { t:= a; a:= b; y:= t; // exchange(a,b) a:= a-b; ggt(a,b) = ggt((a-b)/2,b) return b*2**k; ggt(a,b) = 2*ggT(a/2,b/2) 13

14 Binärer Euklid'scher Algorithmus III - Optimierungen for k:= 0; even(a) and even(b);k++ { a:= a/2; b:= b/2; Die Bestimmung der untersten Anzahl von 0 lässt sich schneller auf der Bitebene bestimmen (Hinweis: Beim Primzahlentest nach Miller-Rabin wird diese Funktion auch gebraucht). while even(a) { a:= a/2; return b*2**k; Auch diese Schiebeoperationen lassen sich durch Erweiterungen der Routinen shiftleft() und shiftright() optimieren. 14

15 Erweiterter Binärer Euklid'scher Algorithmus I Die erweiterte Version arbeitet analog zu der binären Version. Es muss jedoch die lineare Kombination ganzzahlig durch 2 dividiert werden. (1) n= u*a+v*b --> n/2= (u*a+v*b)/2 Das erfolgt mit folgendem Verfahren, das ungerade Werte vermeidet: if even(u) and even(v) { u:= u/2; v:= v/2; else { u:= (u+b)/2; v:= (v-a)/2; Motivation: Die Werte aus dem else-teil oben (1) einsetzen: ((u+b)/2)*a+((v-a)/2)*b= (u*a+a*b+v*b-a*b)/2= (u*a+v*b)/2= n/2 15

16 Erweiterter Binärer Euklid'scher Algorithmus II func BigInt BigInt BigInt egcdbin(bigint a>=0,b>=0) { for int k:= 0; even(a) and even(b);k++ { a:= a/2; b:= b/2; BigInt au:= 1, av:= 0; // for a BigInt bu:= 0, bv:= 1; // for b BigInt x:= a; BigInt y:= b; Teil 1 16

17 Erweiterter Binärer Euklid'scher Algorithmus III while x!=0 { while even(x) { Teil 2 x:= x/2; if even(x) and even(y) { au:= au/2; av:= av/2; else { au:= (au+b)/2; av:= (av-a)/2; while even(y) { y:= y/2; Teil 3 if even(x) and even(y) { bu:= bu/2; bv:= bv/2; else { bu:= (bu+a)/2; bv:= (bv-b)/2; 17

18 Erweiterter Binärer Euklid'scher Algorithmus IV if x<y { y:= y-x; bu:= bu-au; bv:= bv-av; else { x:= x-y; au:= au-bu; av:= av-bv; return b*2**k,bu,bv; Teil 4 18

19 Bemerkungen Wenn die erweiterte Version zum Berechnen der multiplikativen Inversen benutzt wird, sollte im Falle eines negativen Wertes von bu dies durch Addition des Moduls korrigiert werden. Die Hinweise auf die Optimierungen zur normalen Version gelten auch hier. 19

20 Nach dieser Anstrengung etwas Entspannung... 20